Fixes #160

Author: cnuernber

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"

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

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