pythonnet · lostmsu · Sep 21, 2020 · Sep 16, 2020 · Sep 18, 2020 · Sep 18, 2020
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -14,6 +14,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 -   `clr.AddReference` may now throw errors besides `FileNotFoundException`, that provide more
 details about the cause of the failure
 -   `clr.AddReference` no longer adds ".dll" implicitly
+-   `PyIter(PyObject)` constructor replaced with static `PyIter.GetIter(PyObject)` method
 
 ### Fixed
 

diff --git a/src/runtime/pyansistring.cs b/src/runtime/pyansistring.cs
@@ -17,6 +17,16 @@ public PyAnsiString(IntPtr ptr) : base(ptr)
         }
 
 
+        private static IntPtr FromObject(PyObject o)
+        {
+            if (o == null || !IsStringType(o))
+            {
+                throw new ArgumentException("object is not a string");
+            }
+            Runtime.XIncref(o.obj);
+            return o.obj;
+        }
+
         /// <summary>
         /// PyString Constructor
         /// </summary>
@@ -25,14 +35,14 @@ public PyAnsiString(IntPtr ptr) : base(ptr)
         /// An ArgumentException will be thrown if the given object is not
         /// a Python string object.
         /// </remarks>
-        public PyAnsiString(PyObject o)
+        public PyAnsiString(PyObject o) : base(FromObject(o))
         {
-            if (!IsStringType(o))
-            {
-                throw new ArgumentException("object is not a string");
-            }
-            Runtime.XIncref(o.obj);
-            obj = o.obj;
+        }
+        private static IntPtr FromString(string s)
+        {
+            IntPtr val = Runtime.PyString_FromString(s);
+            PythonException.ThrowIfIsNull(val);
+            return val;
         }
 
 
@@ -42,10 +52,8 @@ public PyAnsiString(PyObject o)
         /// <remarks>
         /// Creates a Python string from a managed string.
         /// </remarks>
-        public PyAnsiString(string s)
+        public PyAnsiString(string s) : base(FromString(s))
         {
-            obj = Runtime.PyString_FromString(s);
-            PythonException.ThrowIfIsNull(obj);
         }
 
 

diff --git a/src/runtime/pydict.cs b/src/runtime/pydict.cs
@@ -29,9 +29,8 @@ public PyDict(IntPtr ptr) : base(ptr)
         /// <remarks>
         /// Creates a new Python dictionary object.
         /// </remarks>
-        public PyDict()
+        public PyDict() : base(Runtime.PyDict_New())
         {
-            obj = Runtime.PyDict_New();
             if (obj == IntPtr.Zero)
             {
                 throw new PythonException();
@@ -47,14 +46,13 @@ public PyDict()
         /// ArgumentException will be thrown if the given object is not a
         /// Python dictionary object.
         /// </remarks>
-        public PyDict(PyObject o)
+        public PyDict(PyObject o) : base(o.obj)
         {
+            Runtime.XIncref(o.obj);
             if (!IsDictType(o))
             {
                 throw new ArgumentException("object is not a dict");
             }
-            Runtime.XIncref(o.obj);
-            obj = o.obj;
         }
 
 

diff --git a/src/runtime/pyfloat.cs b/src/runtime/pyfloat.cs
@@ -4,7 +4,6 @@ namespace Python.Runtime
 {
     /// <summary>
     /// Represents a Python float object. See the documentation at
-    /// PY2: https://docs.python.org/2/c-api/float.html
     /// PY3: https://docs.python.org/3/c-api/float.html
     /// for details.
     /// </summary>
@@ -31,14 +30,8 @@ public PyFloat(IntPtr ptr) : base(ptr)
         /// ArgumentException will be thrown if the given object is not a
         /// Python float object.
         /// </remarks>
-        public PyFloat(PyObject o)
+        public PyFloat(PyObject o) : base(FromObject(o))
         {
-            if (!IsFloatType(o))
-            {
-                throw new ArgumentException("object is not a float");
-            }
-            Runtime.XIncref(o.obj);
-            obj = o.obj;
         }
 
 
@@ -48,26 +41,45 @@ public PyFloat(PyObject o)
         /// <remarks>
         /// Creates a new Python float from a double value.
         /// </remarks>
-        public PyFloat(double value)
+        public PyFloat(double value) : base(FromDouble(value))
+        {
+        }
+
+        private static IntPtr FromObject(PyObject o)
+        {
+            if (o == null || !IsFloatType(o))
+            {
+                throw new ArgumentException("object is not a float");
+            }
+            Runtime.XIncref(o.obj);
+            return o.obj;
+        }
+
+        private static IntPtr FromDouble(double value)
         {
-            obj = Runtime.PyFloat_FromDouble(value);
-            PythonException.ThrowIfIsNull(obj);
+            IntPtr val = Runtime.PyFloat_FromDouble(value);
+            PythonException.ThrowIfIsNull(val);
+            return val;
         }
 
+        private static IntPtr FromString(string value)
+        {
+            using (var s = new PyString(value))
+            {
+                IntPtr val = Runtime.PyFloat_FromString(s.obj, IntPtr.Zero);
+                PythonException.ThrowIfIsNull(val);
+                return val;
+            }
+        }
 
         /// <summary>
         /// PyFloat Constructor
         /// </summary>
         /// <remarks>
         /// Creates a new Python float from a string value.
         /// </remarks>
-        public PyFloat(string value)
+        public PyFloat(string value) : base(FromString(value))
         {
-            using (var s = new PyString(value))
-            {
-                obj = Runtime.PyFloat_FromString(s.obj, IntPtr.Zero);
-                PythonException.ThrowIfIsNull(obj);
-            }
         }
 
 

diff --git a/src/runtime/pyint.cs b/src/runtime/pyint.cs
@@ -31,27 +31,35 @@ public PyInt(IntPtr ptr) : base(ptr)
         /// ArgumentException will be thrown if the given object is not a
         /// Python int object.
         /// </remarks>
-        public PyInt(PyObject o)
+        public PyInt(PyObject o) : base(FromObject(o))
         {
-            if (!IsIntType(o))
+        }
+
+        private static IntPtr FromObject(PyObject o)
+        {
+            if (o == null || !IsIntType(o))
             {
                 throw new ArgumentException("object is not an int");
             }
             Runtime.XIncref(o.obj);
-            obj = o.obj;
+            return o.obj;
         }
 
+        private static IntPtr FromInt(int value)
+        {
+            IntPtr val = Runtime.PyInt_FromInt32(value);
+            PythonException.ThrowIfIsNull(val);
+            return val;
+        }
 
         /// <summary>
         /// PyInt Constructor
         /// </summary>
         /// <remarks>
         /// Creates a new Python int from an int32 value.
         /// </remarks>
-        public PyInt(int value)
+        public PyInt(int value) : base(FromInt(value))
         {
-            obj = Runtime.PyInt_FromInt32(value);
-            PythonException.ThrowIfIsNull(obj);
         }
 
 
@@ -62,10 +70,8 @@ public PyInt(int value)
         /// Creates a new Python int from a uint32 value.
         /// </remarks>
         [CLSCompliant(false)]
-        public PyInt(uint value)
+        public PyInt(uint value) : base(FromLong(value))
         {
-            obj = Runtime.PyInt_FromInt64(value);
-            PythonException.ThrowIfIsNull(obj);
         }
 
 
@@ -75,10 +81,15 @@ public PyInt(uint value)
         /// <remarks>
         /// Creates a new Python int from an int64 value.
         /// </remarks>
-        public PyInt(long value)
+        public PyInt(long value) : base(FromLong(value))
         {
-            obj = Runtime.PyInt_FromInt64(value);
-            PythonException.ThrowIfIsNull(obj);
+        }
+
+        private static IntPtr FromLong(long value)
+        {
+            IntPtr val = Runtime.PyInt_FromInt64(value);
+            PythonException.ThrowIfIsNull(val);
+            return val;
         }
 
 
@@ -89,10 +100,8 @@ public PyInt(long value)
         /// Creates a new Python int from a uint64 value.
         /// </remarks>
         [CLSCompliant(false)]
-        public PyInt(ulong value)
+        public PyInt(ulong value) : base(FromLong((long)value))
         {
-            obj = Runtime.PyInt_FromInt64((long)value);
-            PythonException.ThrowIfIsNull(obj);
         }
 
 
@@ -142,16 +151,21 @@ public PyInt(sbyte value) : this((int)value)
         }
 
 
+        private static IntPtr FromString(string value)
+        {
+            IntPtr val = Runtime.PyInt_FromString(value, IntPtr.Zero, 0);
+            PythonException.ThrowIfIsNull(val);
+            return val;
+        }
+
         /// <summary>
         /// PyInt Constructor
         /// </summary>
         /// <remarks>
         /// Creates a new Python int from a string value.
         /// </remarks>
-        public PyInt(string value)
+        public PyInt(string value) : base(FromString(value))
         {
-            obj = Runtime.PyInt_FromString(value, IntPtr.Zero, 0);
-            PythonException.ThrowIfIsNull(obj);
         }
 
 

diff --git a/src/runtime/pyiter.cs b/src/runtime/pyiter.cs
@@ -26,18 +26,22 @@ public PyIter(IntPtr ptr) : base(ptr)
         }
 
         /// <summary>
-        /// PyIter Constructor
+        /// PyIter factory function.
         /// </summary>
         /// <remarks>
-        /// Creates a Python iterator from an iterable. Like doing "iter(iterable)" in python.
+        /// Create a new PyIter from a given iterable.  Like doing "iter(iterable)" in python.
         /// </remarks>
-        public PyIter(PyObject iterable)
+        /// <param name="iterable"></param>
+        /// <returns></returns>
+        public static PyIter GetIter(PyObject iterable)
         {
-            obj = Runtime.PyObject_GetIter(iterable.obj);
-            if (obj == IntPtr.Zero)
+            if (iterable == null)
             {
-                throw new PythonException();
+                throw new ArgumentNullException();
             }
+            IntPtr val = Runtime.PyObject_GetIter(iterable.obj);
+            PythonException.ThrowIfIsNull(val);
+            return new PyIter(val);
         }
 
         protected override void Dispose(bool disposing)

diff --git a/src/runtime/pylist.cs b/src/runtime/pylist.cs
@@ -28,6 +28,16 @@ public PyList(IntPtr ptr) : base(ptr)
         internal PyList(BorrowedReference reference) : base(reference) { }
 
 
+        private static IntPtr FromObject(PyObject o)
+        {
+            if (o == null || !IsListType(o))
+            {
+                throw new ArgumentException("object is not a list");
+            }
+            Runtime.XIncref(o.obj);
+            return o.obj;
+        }
+
         /// <summary>
         /// PyList Constructor
         /// </summary>
@@ -36,14 +46,8 @@ internal PyList(BorrowedReference reference) : base(reference) { }
         /// ArgumentException will be thrown if the given object is not a
         /// Python list object.
         /// </remarks>
-        public PyList(PyObject o)
+        public PyList(PyObject o) : base(FromObject(o))
         {
-            if (!IsListType(o))
-            {
-                throw new ArgumentException("object is not a list");
-            }
-            Runtime.XIncref(o.obj);
-            obj = o.obj;
         }
 
 
@@ -53,36 +57,40 @@ public PyList(PyObject o)
         /// <remarks>
         /// Creates a new empty Python list object.
         /// </remarks>
-        public PyList()
+        public PyList() : base(Runtime.PyList_New(0))
         {
-            obj = Runtime.PyList_New(0);
             if (obj == IntPtr.Zero)
             {
                 throw new PythonException();
             }
         }
 
-
-        /// <summary>
-        /// PyList Constructor
-        /// </summary>
-        /// <remarks>
-        /// Creates a new Python list object from an array of PyObjects.
-        /// </remarks>
-        public PyList(PyObject[] items)
+        private static IntPtr FromArray(PyObject[] items)
         {
             int count = items.Length;
-            obj = Runtime.PyList_New(count);
+            IntPtr val = Runtime.PyList_New(count);
             for (var i = 0; i < count; i++)
             {
                 IntPtr ptr = items[i].obj;
                 Runtime.XIncref(ptr);
-                int r = Runtime.PyList_SetItem(obj, i, ptr);
+                int r = Runtime.PyList_SetItem(val, i, ptr);
                 if (r < 0)
                 {
+                    Runtime.Py_DecRef(val);
                     throw new PythonException();
                 }
             }
+            return val;
+        }
+
+        /// <summary>
+        /// PyList Constructor
+        /// </summary>
+        /// <remarks>
+        /// Creates a new Python list object from an array of PyObjects.
+        /// </remarks>
+        public PyList(PyObject[] items) : base(FromArray(items))
+        {
         }