@@ -6,30 +6,47 @@ namespace Python.Runtime.CollectionWrappers
 {
     internal class IterableWrapper<T> : IEnumerable<T>
     {
-        protected PyObject pyObject;
+        protected readonly PyObject pyObject;
 
         public IterableWrapper(PyObject pyObj)
         {
+            if (pyObj == null)
+                throw new PythonException();
             pyObject = pyObj;
         }
 
         private void propagateIterationException()
         {
             var err = Runtime.PyErr_Occurred();
-            if (err != null && err != Exceptions.StopIteration)
+            if (err == null) return;
+
+            //remove StopIteration exceptions
+            if (0 != Runtime.PyErr_ExceptionMatches(Exceptions.StopIteration))
             {
-                Runtime.CheckExceptionOccurred();
+                Runtime.PyErr_Clear();
+                return;
             }
+
+            Runtime.CheckExceptionOccurred();
         }
 
         IEnumerator IEnumerable.GetEnumerator()
         {
-            if (pyObject == null) yield break;
-            PyObject iterObject = new PyObject(Runtime.PyObject_GetIter(pyObject.Handle));
-            IntPtr item;
+            PyObject iterObject = null;
+            using (Py.GIL())
+            {
+                iterObject = new PyObject(Runtime.PyObject_GetIter(pyObject.Handle));
+            }
 
-            while ((item = Runtime.PyIter_Next(iterObject.Handle)) != IntPtr.Zero)
+            while (true)
             {
+                IntPtr item = IntPtr.Zero;
+                using (Py.GIL())
+                {
+                    item = Runtime.PyIter_Next(iterObject.Handle);
+                }
+                if (item == IntPtr.Zero) break;
+
                 object obj = null;
                 if (!Converter.ToManaged(item, typeof(object), out obj, true))
                 {
@@ -46,7 +63,6 @@ IEnumerator IEnumerable.GetEnumerator()
 
         public IEnumerator<T> GetEnumerator()
         {
-            if (pyObject == null) yield break;
             PyObject iterObject = null;
             using (Py.GIL())
             {
 
@@ -26,10 +26,13 @@ public T this[int index]
             {
                 IntPtr pyItem = Converter.ToPython(value, typeof(T));
                 if (pyItem == IntPtr.Zero)
-                    throw new Exception("failed to set item");
+                {
+                    throw new InvalidCastException(
+                        "cannot cast " + value.ToString() + "to type: " + typeof(T).ToString(),
+                        new PythonException());
+                }
 
                 var result = Runtime.PyList_SetItem(pyObject.Handle, index, pyItem);
-                Runtime.XDecref(pyItem);
                 if (result == -1)
                     Runtime.CheckExceptionOccurred();
             }
@@ -47,7 +50,7 @@ public void Insert(int index, T item)
 
             IntPtr pyItem = Converter.ToPython(item, typeof(T));
             if (pyItem == IntPtr.Zero)
-                throw new Exception("failed to insert item");
+                throw new PythonException();
 
             var result = Runtime.PyList_Insert(pyObject.Reference, index, pyItem);
             Runtime.XDecref(pyItem);
@@ -57,7 +60,12 @@ public void Insert(int index, T item)
 
         public void RemoveAt(int index)
         {
-            removeAt(index);
+            var result = removeAt(index);
+
+            //PySequence_DelItem will set an error if it fails.  throw it here
+            //since RemoveAt does not have a bool return value.
+            if (result == false)
+                Runtime.CheckExceptionOccurred();
         }
     }
 }
@@ -72,9 +72,11 @@ private T getItem(int index)
 
         public void CopyTo(T[] array, int arrayIndex)
         {
-            for (int index = 0; index < Count; index++)
+            var index = 0;
+            foreach (var item in this)
             {
-                array[index + arrayIndex] = getItem(index);
+                array[index + arrayIndex] = item;
+                index++;
             }
         }
 
@@ -102,7 +104,14 @@ protected int indexOf(T item)
 
         public bool Remove(T item)
         {
-            return removeAt(indexOf(item));
+            var result = removeAt(indexOf(item));
+
+            //clear the python exception from PySequence_DelItem
+            //it is idiomatic in C# to return a bool rather than
+            //throw for a failed Remove in ICollection
+            if (result == false)
+                Runtime.PyErr_Clear();
+            return result;
         }
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -6,30 +6,47 @@ namespace Python.Runtime.CollectionWrappers`
`6`	`6`	`{`
`7`	`7`	`internal class IterableWrapper<T> : IEnumerable<T>`
`8`	`8`	`{`
`9`		`- protected PyObject pyObject;`
	`9`	`+ protected readonly PyObject pyObject;`
`10`	`10`
`11`	`11`	`public IterableWrapper(PyObject pyObj)`
`12`	`12`	`{`
	`13`	`+ if (pyObj == null)`
	`14`	`+ throw new PythonException();`
`13`	`15`	`pyObject = pyObj;`
`14`	`16`	`}`
`15`	`17`
`16`	`18`	`private void propagateIterationException()`
`17`	`19`	`{`
`18`	`20`	`var err = Runtime.PyErr_Occurred();`
`19`		`- if (err != null && err != Exceptions.StopIteration)`
	`21`	`+ if (err == null) return;`
	`22`	`+`
	`23`	`+ //remove StopIteration exceptions`
	`24`	`+ if (0 != Runtime.PyErr_ExceptionMatches(Exceptions.StopIteration))`
`20`	`25`	`{`
`21`		`- Runtime.CheckExceptionOccurred();`
	`26`	`+ Runtime.PyErr_Clear();`
	`27`	`+ return;`
`22`	`28`	`}`
	`29`	`+`
	`30`	`+ Runtime.CheckExceptionOccurred();`
`23`	`31`	`}`
`24`	`32`
`25`	`33`	`IEnumerator IEnumerable.GetEnumerator()`
`26`	`34`	`{`
`27`		`- if (pyObject == null) yield break;`
`28`		`- PyObject iterObject = new PyObject(Runtime.PyObject_GetIter(pyObject.Handle));`
`29`		`- IntPtr item;`
	`35`	`+ PyObject iterObject = null;`
	`36`	`+ using (Py.GIL())`
	`37`	`+ {`
	`38`	`+ iterObject = new PyObject(Runtime.PyObject_GetIter(pyObject.Handle));`
	`39`	`+ }`
`30`	`40`
`31`		`- while ((item = Runtime.PyIter_Next(iterObject.Handle)) != IntPtr.Zero)`
	`41`	`+ while (true)`
`32`	`42`	`{`
	`43`	`+ IntPtr item = IntPtr.Zero;`
	`44`	`+ using (Py.GIL())`
	`45`	`+ {`
	`46`	`+ item = Runtime.PyIter_Next(iterObject.Handle);`
	`47`	`+ }`
	`48`	`+ if (item == IntPtr.Zero) break;`
	`49`	`+`
`33`	`50`	`object obj = null;`
`34`	`51`	`if (!Converter.ToManaged(item, typeof(object), out obj, true))`
`35`	`52`	`{`
`@@ -46,7 +63,6 @@ IEnumerator IEnumerable.GetEnumerator()`
`46`	`63`
`47`	`64`	`public IEnumerator<T> GetEnumerator()`
`48`	`65`	`{`
`49`		`- if (pyObject == null) yield break;`
`50`	`66`	`PyObject iterObject = null;`
`51`	`67`	`using (Py.GIL())`
`52`	`68`	`{`
Original file line number	Diff line number	Diff line change
`@@ -26,10 +26,13 @@ public T this[int index]`
`26`	`26`	`{`
`27`	`27`	`IntPtr pyItem = Converter.ToPython(value, typeof(T));`
`28`	`28`	`if (pyItem == IntPtr.Zero)`
`29`		`- throw new Exception("failed to set item");`
	`29`	`+ {`
	`30`	`+ throw new InvalidCastException(`
	`31`	`+ "cannot cast " + value.ToString() + "to type: " + typeof(T).ToString(),`
	`32`	`+ new PythonException());`
	`33`	`+ }`
`30`	`34`
`31`	`35`	`var result = Runtime.PyList_SetItem(pyObject.Handle, index, pyItem);`
`32`		`- Runtime.XDecref(pyItem);`
`33`	`36`	`if (result == -1)`
`34`	`37`	`Runtime.CheckExceptionOccurred();`
`35`	`38`	`}`
`@@ -47,7 +50,7 @@ public void Insert(int index, T item)`
`47`	`50`
`48`	`51`	`IntPtr pyItem = Converter.ToPython(item, typeof(T));`
`49`	`52`	`if (pyItem == IntPtr.Zero)`
`50`		`- throw new Exception("failed to insert item");`
	`53`	`+ throw new PythonException();`
`51`	`54`
`52`	`55`	`var result = Runtime.PyList_Insert(pyObject.Reference, index, pyItem);`
`53`	`56`	`Runtime.XDecref(pyItem);`
`@@ -57,7 +60,12 @@ public void Insert(int index, T item)`
`57`	`60`
`58`	`61`	`public void RemoveAt(int index)`
`59`	`62`	`{`
`60`		`- removeAt(index);`
	`63`	`+ var result = removeAt(index);`
	`64`	`+`
	`65`	`+ //PySequence_DelItem will set an error if it fails. throw it here`
	`66`	`+ //since RemoveAt does not have a bool return value.`
	`67`	`+ if (result == false)`
	`68`	`+ Runtime.CheckExceptionOccurred();`
`61`	`69`	`}`
`62`	`70`	`}`
`63`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,9 +72,11 @@ private T getItem(int index)`
`72`	`72`
`73`	`73`	`public void CopyTo(T[] array, int arrayIndex)`
`74`	`74`	`{`
`75`		`- for (int index = 0; index < Count; index++)`
	`75`	`+ var index = 0;`
	`76`	`+ foreach (var item in this)`
`76`	`77`	`{`
`77`		`- array[index + arrayIndex] = getItem(index);`
	`78`	`+ array[index + arrayIndex] = item;`
	`79`	`+ index++;`
`78`	`80`	`}`
`79`	`81`	`}`
`80`	`82`
`@@ -102,7 +104,14 @@ protected int indexOf(T item)`
`102`	`104`
`103`	`105`	`public bool Remove(T item)`
`104`	`106`	`{`
`105`		`- return removeAt(indexOf(item));`
	`107`	`+ var result = removeAt(indexOf(item));`
	`108`	`+`
	`109`	`+ //clear the python exception from PySequence_DelItem`
	`110`	`+ //it is idiomatic in C# to return a bool rather than`
	`111`	`+ //throw for a failed Remove in ICollection`
	`112`	`+ if (result == false)`
	`113`	`+ Runtime.PyErr_Clear();`
	`114`	`+ return result;`
`106`	`115`	`}`
`107`	`116`	`}`
`108`	`117`	`}`