From 972e416dbf2737f7c5827f2f255ceaf7db593506 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Mon, 20 Feb 2017 10:59:56 +0200
Subject: [PATCH 1/2] bpo-29532: Altering a kwarg dictionary passed to
 functools.partial() no longer affects a partial object after creation.

---
 Lib/test/test_functools.py | 9 +++++++++
 Misc/NEWS                  | 3 +++
 Modules/_functoolsmodule.c | 5 ++++-
 3 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index 63fe83e5dbd602..612ca17a60bc8c 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -90,6 +90,15 @@ def func(a=10, b=20):
         p(b=7)
         self.assertEqual(d, {'a':3})
 
+    def test_kwargs_copy(self):
+        # Issue #29532: Altering a kwarg dictionary passed to a constructor
+        # should not affect a partial object after creation
+        d = {'a': 3}
+        p = self.partial(capture, **d)
+        self.assertEqual(p(), ((), {'a': 3}))
+        d['a'] = 5
+        self.assertEqual(p(), ((), {'a': 3}))
+
     def test_arg_combinations(self):
         # exercise special code paths for zero args in either partial
         # object or the caller
diff --git a/Misc/NEWS b/Misc/NEWS
index 0c2a5730e31388..fa7e3f5a5e7f06 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -232,6 +232,9 @@ Extension Modules
 Library
 -------
 
+- bpo-29532: Altering a kwarg dictionary passed to functools.partial()
+  no longer affects a partial object after creation.
+
 - bpo-22807: Add uuid.SafeUUID and uuid.UUID.is_safe to relay information from
   the platform about whether generated UUIDs are generated with a
   multiprocessing safe method.
diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c
index 4170883368f953..c8565054c903de 100644
--- a/Modules/_functoolsmodule.c
+++ b/Modules/_functoolsmodule.c
@@ -88,10 +88,13 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
         if (kw == NULL) {
             pto->kw = PyDict_New();
         }
-        else {
+        else if (Py_REFCNT(kw) == 1) {
             Py_INCREF(kw);
             pto->kw = kw;
         }
+        else {
+            pto->kw = PyDict_Copy(kw);
+        }
     }
     else {
         pto->kw = PyDict_Copy(pkw);

From 5eb7e0964a134cf32ece43e1268ba453b617ad31 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Mon, 20 Feb 2017 21:45:22 +0200
Subject: [PATCH 2/2] bpo-29602: complex() on complex-like object no longer
 loses sign of zero imaginary part.

---
 Lib/test/test_complex.py | 23 +++++++++++++++++++++++
 Misc/NEWS                |  3 +++
 Objects/complexobject.c  |  6 +++---
 3 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py
index c249ca724bf0ce..cee49343e268a2 100644
--- a/Lib/test/test_complex.py
+++ b/Lib/test/test_complex.py
@@ -387,6 +387,29 @@ def __complex__(self):
         self.assertAlmostEqual(complex(complex1(1j)), 2j)
         self.assertRaises(TypeError, complex, complex2(1j))
 
+    @support.requires_IEEE_754
+    def test_constructor_special_numbers(self):
+        class complex2(complex):
+            pass
+        for x in 0.0, -0.0, INF, -INF, NAN:
+            for y in 0.0, -0.0, INF, -INF, NAN:
+                with self.subTest(x=x, y=y):
+                    z = complex(x, y)
+                    self.assertFloatsAreIdentical(z.real, x)
+                    self.assertFloatsAreIdentical(z.imag, y)
+                    z = complex2(x, y)
+                    self.assertIs(type(z), complex2)
+                    self.assertFloatsAreIdentical(z.real, x)
+                    self.assertFloatsAreIdentical(z.imag, y)
+                    z = complex(complex2(x, y))
+                    self.assertIs(type(z), complex)
+                    self.assertFloatsAreIdentical(z.real, x)
+                    self.assertFloatsAreIdentical(z.imag, y)
+                    z = complex2(complex(x, y))
+                    self.assertIs(type(z), complex2)
+                    self.assertFloatsAreIdentical(z.real, x)
+                    self.assertFloatsAreIdentical(z.imag, y)
+
     def test_underscores(self):
         # check underscores
         for lit in VALID_UNDERSCORE_LITERALS:
diff --git a/Misc/NEWS b/Misc/NEWS
index fa7e3f5a5e7f06..f9128ff92e73da 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -10,6 +10,9 @@ What's New in Python 3.7.0 alpha 1?
 Core and Builtins
 -----------------
 
+- bpo-29602: complex() on complex-like object no longer loses sign of zero
+  imaginary part.
+
 - bpo-29347: Fixed possibly dereferencing undefined pointers
   when creating weakref objects.
 
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index 0d391e5208cc77..5cc17ffbe27dd6 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -1025,11 +1025,11 @@ complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
             return NULL;
         }
         cr.real = PyFloat_AsDouble(tmp);
-        cr.imag = 0.0; /* Shut up compiler warning */
+        cr.imag = 0.0;
         Py_DECREF(tmp);
     }
     if (i == NULL) {
-        ci.real = 0.0;
+        ci.real = cr.imag;
     }
     else if (PyComplex_Check(i)) {
         ci = ((PyComplexObject*)i)->cval;
@@ -1051,7 +1051,7 @@ complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     if (ci_is_complex) {
         cr.real -= ci.imag;
     }
-    if (cr_is_complex) {
+    if (cr_is_complex && i != NULL) {
         ci.real += cr.imag;
     }
     return complex_subtype_from_doubles(type, cr.real, ci.real);