Adds support to convert iterators to arrays

Joe Lidbetter · Joe Lidbetter · commit 2e513211ce07 · 2019-08-02T08:47:31.000+01:00
diff --git a/AUTHORS.md b/AUTHORS.md
@@ -33,6 +33,7 @@
 -   Jan Krivanek ([@jakrivan](https://github.com/jakrivan))
 -   Jeff Reback ([@jreback](https://github.com/jreback))
 -   Joe Frayne ([@jfrayne](https://github.com/jfrayne))
+-   Joe Lidbetter ([@jmlidbetter](https://github.com/jmlidbetter))
 -   John Burnett ([@johnburnett](https://github.com/johnburnett))
 -   John Wilkes ([@jbw3](https://github.com/jbw3))
 -   Luke Stratman ([@lstratman](https://github.com/lstratman))
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -15,6 +15,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 
 -   Added argument types information to "No method matches given arguments" message
 -   Moved wheel import in setup.py inside of a try/except to prevent pip collection failures
+-   Added support for converting python iterators to C# arrays
 
 ### Fixed
 
diff --git a/src/runtime/converter.cs b/src/runtime/converter.cs
@@ -837,48 +837,98 @@ private static void SetConversionError(IntPtr value, Type target)
 
         /// <summary>
         /// Convert a Python value to a correctly typed managed array instance.
-        /// The Python value must support the Python sequence protocol and the
-        /// items in the sequence must be convertible to the target array type.
+        /// The Python value must support either the Python sequence protocol or
+        /// the Python iterator protocol and the items in the sequence must be
+        /// convertible to the target array type.
         /// </summary>
         private static bool ToArray(IntPtr value, Type obType, out object result, bool setError)
         {
             Type elementType = obType.GetElementType();
-            var size = Runtime.PySequence_Size(value);
             result = null;
 
-            if (size < 0)
+            bool IsSeqObj = Runtime.PySequence_Check(value);
+
+            // If object does not support Sequence Protocol check if it supports iterator protocol
+            IntPtr IterObject = IntPtr.Zero;
+            if(!IsSeqObj)
             {
+                IterObject = Runtime.PyObject_GetIter(value);
+            }
+
+            if(!IsSeqObj && IterObject==IntPtr.Zero) {
+                // Bail if both sequence check and iterator conversion attempt fail
                 if (setError)
                 {
                     SetConversionError(value, obType);
                 }
                 return false;
             }
 
-            Array items = Array.CreateInstance(elementType, size);
+            Array items;
 
             // XXX - is there a better way to unwrap this if it is a real array?
-            for (var i = 0; i < size; i++)
+            if (IsSeqObj)
             {
-                object obj = null;
-                IntPtr item = Runtime.PySequence_GetItem(value, i);
-                if (item == IntPtr.Zero)
+                // If we have a sequence object use the sequence protocol
+                var size = Runtime.PySequence_Size(value);
+                if (size < 0)
                 {
                     if (setError)
                     {
                         SetConversionError(value, obType);
+                    }
+                    return false;
+                }
+
+                items = Array.CreateInstance(elementType, size);
+                for (var i = 0; i < size; i++)
+                {
+                    object obj = null;
+                    IntPtr item = Runtime.PySequence_GetItem(value, i);
+                    if (item == IntPtr.Zero)
+                    {
+                        if (setError)
+                        {
+                            SetConversionError(value, obType);
+                        }
                         return false;
                     }
+
+                    if (!Converter.ToManaged(item, elementType, out obj, true))
+                    {
+                        Runtime.XDecref(item);
+                        return false;
+                    }
+
+                    items.SetValue(obj, i);
+                    Runtime.XDecref(item);
                 }
+            }
+            else
+            {
+                // Otherwise use iterator protocol
+                var listType = typeof(List<>);
+                var constructedListType = listType.MakeGenericType(elementType);
+                IList list = (IList) Activator.CreateInstance(constructedListType);
+                IntPtr item;
 
-                if (!Converter.ToManaged(item, elementType, out obj, true))
+                while ((item = Runtime.PyIter_Next(IterObject)) != IntPtr.Zero)
                 {
+                    object obj = null;
+
+                    if (!Converter.ToManaged(item, elementType, out obj, true))
+                    {
+                        Runtime.XDecref(item);
+                        return false;
+                    }
+
+                    list.Add(obj);
                     Runtime.XDecref(item);
-                    return false;
                 }
+                Runtime.XDecref(IterObject);
 
-                items.SetValue(obj, i);
-                Runtime.XDecref(item);
+                items = Array.CreateInstance(elementType, list.Count);
+                list.CopyTo(items, 0);
             }
 
             result = items;
diff --git a/src/tests/test_array.py b/src/tests/test_array.py
@@ -1337,3 +1337,34 @@ def test_array_abuse():
     with pytest.raises(TypeError):
         desc = Test.PublicArrayTest.__dict__['__setitem__']
         desc(0, 0, 0)
+
+
+@pytest.mark.skipif(PY2, reason="Only applies in Python 3")
+def test_iterator_to_array():
+    from System import Array, String
+
+    d = {"a": 1, "b": 2, "c": 3}
+    keys_iterator = iter(d.keys())
+    arr = Array[String](keys_iterator)
+
+    Array.Sort(arr)
+
+    assert arr[0] == "a"
+    assert arr[1] == "b"
+    assert arr[2] == "c"
+
+
+@pytest.mark.skipif(PY2, reason="Only applies in Python 3")
+def test_dict_keys_to_array():
+    from System import Array, String
+
+    d = {"a": 1, "b": 2, "c": 3}
+    d_keys = d.keys()
+    arr = Array[String](d_keys)
+
+    Array.Sort(arr)
+
+    assert arr[0] == "a"
+    assert arr[1] == "b"
+    assert arr[2] == "c"
+
