python
diff --git a/‎Lib/ctypes/test/test_numbers.py‎
Lines changed: 17 additions & 1 deletion b/‎Lib/ctypes/test/test_numbers.py‎
Lines changed: 17 additions & 1 deletion
diff --git a/‎Lib/decimal.py‎
Lines changed: 2 additions & 0 deletions b/‎Lib/decimal.py‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎Lib/pprint.py‎
Lines changed: 8 additions & 2 deletions b/‎Lib/pprint.py‎
Lines changed: 8 additions & 2 deletions
diff --git a/‎Lib/rational.py‎
Lines changed: 48 additions & 24 deletions b/‎Lib/rational.py‎
Lines changed: 48 additions & 24 deletions
diff --git a/‎Lib/test/crashers/loosing_dict_ref.py‎
Lines changed: 0 additions & 21 deletions b/‎Lib/test/crashers/loosing_dict_ref.py‎
Lines changed: 0 additions & 21 deletions
diff --git a/‎Lib/test/test_decimal.py‎
Lines changed: 11 additions & 0 deletions b/‎Lib/test/test_decimal.py‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎Lib/test/test_descr.py‎
Lines changed: 24 additions & 0 deletions b/‎Lib/test/test_descr.py‎
Lines changed: 24 additions & 0 deletions
diff --git a/‎Lib/test/test_grammar.py‎
Lines changed: 9 additions & 0 deletions b/‎Lib/test/test_grammar.py‎
Lines changed: 9 additions & 0 deletions
@@ -105,15 +105,31 @@ def test_byref(self):
     def test_floats(self):
         # c_float and c_double can be created from
         # Python int, long and float
+        class FloatLike(object):
+            def __float__(self):
+                return 2.0
+        f = FloatLike()
         for t in float_types:
             self.failUnlessEqual(t(2.0).value, 2.0)
             self.failUnlessEqual(t(2).value, 2.0)
             self.failUnlessEqual(t(2).value, 2.0)
+            self.failUnlessEqual(t(f).value, 2.0)
 
     def test_integers(self):
-        # integers cannot be constructed from floats
+        class FloatLike(object):
+            def __float__(self):
+                return 2.0
+        f = FloatLike()
+        class IntLike(object):
+            def __int__(self):
+                return 2
+        i = IntLike()
+        # integers cannot be constructed from floats,
+        # but from integer-like objects
         for t in signed_types + unsigned_types:
             self.assertRaises(TypeError, t, 3.14)
+            self.assertRaises(TypeError, t, f)
+            self.failUnlessEqual(t(i).value, 2)
 
     def test_sizes(self):
         for t in signed_types + unsigned_types + float_types + bool_types:
 
@@ -1451,6 +1451,8 @@ def __int__(self):
         else:
             return s*int(self._int[:self._exp] or '0')
 
+    __trunc__ = __int__
+
     def _fix_nan(self, context):
         """Decapitate the payload of a NaN to fit the context"""
         payload = self._int
 
@@ -164,25 +164,31 @@ def _format(self, object, stream, indent, allowance, context, level):
                 (issubclass(typ, set) and r is set.__repr__) or
                 (issubclass(typ, frozenset) and r is frozenset.__repr__)
                ):
+                length = _len(object)
                 if issubclass(typ, list):
                     write('[')
                     endchar = ']'
                 elif issubclass(typ, set):
+                    if not length:
+                        write('set()')
+                        return
                     write('{')
                     endchar = '}'
                     object = sorted(object)
                     indent += 4
                 elif issubclass(typ, frozenset):
+                    if not length:
+                        write('frozenset()')
+                        return
                     write('frozenset([')
                     endchar = '])'
                     object = sorted(object)
-                    indent += 9
+                    indent += 10
                 else:
                     write('(')
                     endchar = ')'
                 if self._indent_per_level > 1:
                     write((self._indent_per_level - 1) * ' ')
-                length = _len(object)
                 if length:
                     context[objid] = 1
                     indent = indent + self._indent_per_level
 
@@ -13,7 +13,7 @@
 RationalAbc = numbers.Rational
 
 
-def _gcd(a, b):
+def _gcd(a, b):                     # XXX This is a useful function. Consider making it public.
     """Calculate the Greatest Common Divisor.
 
     Unless b==0, the result will have the same sign as b (so that when
@@ -39,6 +39,8 @@ def _binary_float_to_ratio(x):
     >>> _binary_float_to_ratio(-.25)
     (-1, 4)
     """
+    # XXX Consider moving this to to floatobject.c
+    # with a name like float.as_intger_ratio()
 
     if x == 0:
         return 0, 1
@@ -79,6 +81,10 @@ def _binary_float_to_ratio(x):
 _RATIONAL_FORMAT = re.compile(
     r'^\s*(?P<sign>[-+]?)(?P<num>\d+)(?:/(?P<denom>\d+))?\s*$')
 
+# XXX Consider accepting decimal strings as input since they are exact.
+# Rational("2.01") --> s="2.01" ; Rational.from_decimal(Decimal(s)) --> Rational(201, 100)"
+# If you want to avoid going through the decimal module, just parse the string directly:
+# s.partition('.') --> ('2', '.', '01') --> Rational(int('2'+'01'), 10**len('01')) --> Rational(201, 100)
 
 class Rational(RationalAbc):
     """This class implements rational numbers.
@@ -93,7 +99,7 @@ class Rational(RationalAbc):
 
     """
 
-    __slots__ = ('_numerator', '_denominator')
+    __slots__ = ('numerator', 'denominator')
 
     # We're immutable, so use __new__ not __init__
     def __new__(cls, numerator=0, denominator=1):
@@ -133,8 +139,8 @@ def __new__(cls, numerator=0, denominator=1):
             raise ZeroDivisionError('Rational(%s, 0)' % numerator)
 
         g = _gcd(numerator, denominator)
-        self._numerator = int(numerator // g)
-        self._denominator = int(denominator // g)
+        self.numerator = int(numerator // g)
+        self.denominator = int(denominator // g)
         return self
 
     @classmethod
@@ -192,29 +198,22 @@ def as_continued_fraction(self):
             n, d = d, n
         return cf
 
-    @classmethod
-    def approximate_from_float(cls, f, max_denominator):
-        'Best rational approximation to f with a denominator <= max_denominator'
+    def approximate(self, max_denominator):
+        'Best rational approximation with a denominator <= max_denominator'
         # XXX First cut at algorithm
         # Still needs rounding rules as specified at
         #       http://en.wikipedia.org/wiki/Continued_fraction
-        cf = cls.from_float(f).as_continued_fraction()
+        if self.denominator <= max_denominator:
+            return self
+        cf = self.as_continued_fraction()
         result = Rational(0)
         for i in range(1, len(cf)):
-            new = cls.from_continued_fraction(cf[:i])
+            new = self.from_continued_fraction(cf[:i])
             if new.denominator > max_denominator:
                 break
             result = new
         return result
 
-    @property
-    def numerator(a):
-        return a._numerator
-
-    @property
-    def denominator(a):
-        return a._denominator
-
     def __repr__(self):
         """repr(self)"""
         return ('Rational(%r,%r)' % (self.numerator, self.denominator))
@@ -226,6 +225,16 @@ def __str__(self):
         else:
             return '%s/%s' % (self.numerator, self.denominator)
 
+    """ XXX This section needs a lot more commentary
+
+    * Explain the typical sequence of checks, calls, and fallbacks.
+    * Explain the subtle reasons why this logic was needed.
+    * It is not clear how common cases are handled (for example, how
+      does the ratio of two huge integers get converted to a float
+      without overflowing the long-->float conversion.
+
+    """
+
     def _operator_fallbacks(monomorphic_operator, fallback_operator):
         """Generates forward and reverse operators given a purely-rational
         operator and a function from the operator module.
@@ -299,18 +308,15 @@ def __rfloordiv__(b, a):
         """a // b"""
         return math.floor(a / b)
 
-    @classmethod
-    def _mod(cls, a, b):
-        div = a // b
-        return a - b * div
-
     def __mod__(a, b):
         """a % b"""
-        return a._mod(a, b)
+        div = a // b
+        return a - b * div
 
     def __rmod__(b, a):
         """a % b"""
-        return b._mod(a, b)
+        div = a // b
+        return a - b * div
 
     def __pow__(a, b):
         """a ** b
@@ -369,6 +375,8 @@ def __trunc__(a):
         else:
             return a.numerator // a.denominator
 
+    __int__ = __trunc__
+
     def __floor__(a):
         """Will be math.floor(a) in 3.0."""
         return a.numerator // a.denominator
@@ -410,6 +418,7 @@ def __hash__(self):
         float must have the same hash as that float.
 
         """
+        # XXX since this method is expensive, consider caching the result
         if self.denominator == 1:
             # Get integers right.
             return hash(self.numerator)
@@ -481,3 +490,18 @@ def __ge__(a, b):
     def __bool__(a):
         """a != 0"""
         return a.numerator != 0
+
+    # support for pickling, copy, and deepcopy
+
+    def __reduce__(self):
+        return (self.__class__, (str(self),))
+
+    def __copy__(self):
+        if type(self) == Rational:
+            return self     # I'm immutable; therefore I am my own clone
+        return self.__class__(self.numerator, self.denominator)
+
+    def __deepcopy__(self, memo):
+        if type(self) == Rational:
+            return self     # My components are also immutable
+        return self.__class__(self.numerator, self.denominator)
@@ -1141,6 +1141,7 @@ def checkSameDec(operation, useOther=False):
         checkSameDec("__floordiv__", True)
         checkSameDec("__hash__")
         checkSameDec("__int__")
+        checkSameDec("__trunc__")
         checkSameDec("__mod__", True)
         checkSameDec("__mul__", True)
         checkSameDec("__neg__")
@@ -1204,6 +1205,16 @@ def test_int(self):
             r = d.to_integral(ROUND_DOWN)
             self.assertEqual(Decimal(int(d)), r)
 
+    def test_trunc(self):
+        for x in range(-250, 250):
+            s = '%0.2f' % (x / 100.0)
+            # should work the same as for floats
+            self.assertEqual(int(Decimal(s)), int(float(s)))
+            # should work the same as to_integral in the ROUND_DOWN mode
+            d = Decimal(s)
+            r = d.to_integral(ROUND_DOWN)
+            self.assertEqual(Decimal(trunc(d)), r)
+
 class ContextAPItests(unittest.TestCase):
 
     def test_pickle(self):
 
@@ -4248,6 +4248,29 @@ def __call__(self, *args):
     finally:
         builtins.__import__ = orig_import
 
+def test_losing_dict_ref_segfault():
+    # This used to segfault;
+    # derived from issue #1303614, test67.py
+    if verbose:
+        print("Testing losing dict ref segfault...")
+
+    class Strange(object):
+        def __hash__(self):
+            return hash('hello')
+
+        def __eq__(self, other):
+            x.__dict__ = {}   # the old x.__dict__ is deallocated
+            return False
+
+    class X(object):
+        pass
+
+    v = 123
+    x = X()
+    x.__dict__ = {Strange(): 42, 'hello': v+456}
+    x.hello
+
+
 def test_main():
     weakref_segfault() # Must be first, somehow
     wrapper_segfault() # NB This one is slow
@@ -4348,6 +4371,7 @@ def test_main():
     test_weakref_in_del_segfault()
     test_borrowed_ref_3_segfault()
     test_borrowed_ref_4_segfault()
+    test_losing_dict_ref_segfault()
 
     if verbose: print("All OK")
 
 
@@ -500,6 +500,15 @@ def testWhile(self):
         while 0: pass
         else: pass
 
+        # Issue1920: "while 0" is optimized away,
+        # ensure that the "else" clause is still present.
+        x = 0
+        while 0:
+            x = 1
+        else:
+            x = 2
+        self.assertEquals(x, 2)
+
     def testFor(self):
         # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
         for i in 1, 2, 3: pass