From a60c2fe4807e89a5844979fe46b3ea39572fc3be Mon Sep 17 00:00:00 2001 From: Serhiy Storchaka Date: Thu, 12 Mar 2015 21:56:08 +0200 Subject: [PATCH] Issue #23641: Cleaned out legacy dunder names from tests and docs. Fixed 2 to 3 porting bug in pynche.ColorDB. --- Doc/library/multiprocessing.rst | 2 +- Doc/library/unittest.mock.rst | 12 +++--- Lib/datetime.py | 7 ++-- Lib/decimal.py | 11 +++-- Lib/sqlite3/test/types.py | 15 ++----- Lib/test/mapping_tests.py | 2 +- Lib/test/test_abc.py | 4 +- Lib/test/test_augassign.py | 8 ---- Lib/test/test_class.py | 34 +++++++++++----- Lib/test/test_descr.py | 24 ++++------- Lib/test/test_dynamicclassattribute.py | 4 +- Lib/test/test_inspect.py | 2 +- Lib/test/test_itertools.py | 2 +- Lib/test/test_property.py | 4 +- Lib/test/test_unicode.py | 56 +++++--------------------- Modules/_decimal/tests/deccheck.py | 2 +- Modules/mathmodule.c | 2 +- Tools/clinic/clinic.py | 1 - Tools/pynche/ColorDB.py | 4 +- 19 files changed, 72 insertions(+), 124 deletions(-) diff --git a/Doc/library/multiprocessing.rst b/Doc/library/multiprocessing.rst index ecac5b01a12..cbec3305ce5 100644 --- a/Doc/library/multiprocessing.rst +++ b/Doc/library/multiprocessing.rst @@ -1831,7 +1831,7 @@ itself. This means, for example, that one shared object can contain a second: >>> l = manager.list(range(10)) >>> l._callmethod('__len__') 10 - >>> l._callmethod('__getslice__', (2, 7)) # equiv to `l[2:7]` + >>> l._callmethod('__getitem__', (slice(2, 7),)) # equiv to `l[2:7]` [2, 3, 4, 5, 6] >>> l._callmethod('__getitem__', (20,)) # equiv to `l[20]` Traceback (most recent call last): diff --git a/Doc/library/unittest.mock.rst b/Doc/library/unittest.mock.rst index 845e0c41e63..91d5a278277 100644 --- a/Doc/library/unittest.mock.rst +++ b/Doc/library/unittest.mock.rst @@ -1579,19 +1579,19 @@ The full list of supported magic methods is: * ``__hash__``, ``__sizeof__``, ``__repr__`` and ``__str__`` * ``__dir__``, ``__format__`` and ``__subclasses__`` * ``__floor__``, ``__trunc__`` and ``__ceil__`` -* Comparisons: ``__cmp__``, ``__lt__``, ``__gt__``, ``__le__``, ``__ge__``, +* Comparisons: ``__lt__``, ``__gt__``, ``__le__``, ``__ge__``, ``__eq__`` and ``__ne__`` * Container methods: ``__getitem__``, ``__setitem__``, ``__delitem__``, - ``__contains__``, ``__len__``, ``__iter__``, ``__getslice__``, - ``__setslice__``, ``__reversed__`` and ``__missing__`` + ``__contains__``, ``__len__``, ``__iter__``, ``__reversed__`` + and ``__missing__`` * Context manager: ``__enter__`` and ``__exit__`` * Unary numeric methods: ``__neg__``, ``__pos__`` and ``__invert__`` * The numeric methods (including right hand and in-place variants): - ``__add__``, ``__sub__``, ``__mul__``, ``__div__``, + ``__add__``, ``__sub__``, ``__mul__``, ``__div__``,``__truediv__``, ``__floordiv__``, ``__mod__``, ``__divmod__``, ``__lshift__``, ``__rshift__``, ``__and__``, ``__xor__``, ``__or__``, and ``__pow__`` -* Numeric conversion methods: ``__complex__``, ``__int__``, ``__float__``, - ``__index__`` and ``__coerce__`` +* Numeric conversion methods: ``__complex__``, ``__int__``, ``__float__`` + and ``__index__`` * Descriptor methods: ``__get__``, ``__set__`` and ``__delete__`` * Pickling: ``__reduce__``, ``__reduce_ex__``, ``__getinitargs__``, ``__getnewargs__``, ``__getstate__`` and ``__setstate__`` diff --git a/Lib/datetime.py b/Lib/datetime.py index 4c442f21390..34e5d387cfa 100644 --- a/Lib/datetime.py +++ b/Lib/datetime.py @@ -646,7 +646,7 @@ class date: Operators: __repr__, __str__ - __cmp__, __hash__ + __eq__, __le__, __lt__, __ge__, __gt__, __hash__ __add__, __radd__, __sub__ (add/radd only with timedelta arg) Methods: @@ -776,7 +776,8 @@ class date: """day (1-31)""" return self._day - # Standard conversions, __cmp__, __hash__ (and helpers) + # Standard conversions, __eq__, __le__, __lt__, __ge__, __gt__, + # __hash__ (and helpers) def timetuple(self): "Return local time tuple compatible with time.localtime()." @@ -1005,7 +1006,7 @@ class time: Operators: __repr__, __str__ - __cmp__, __hash__ + __eq__, __le__, __lt__, __ge__, __gt__, __hash__ Methods: diff --git a/Lib/decimal.py b/Lib/decimal.py index b254f9cd86c..324e4f91cae 100644 --- a/Lib/decimal.py +++ b/Lib/decimal.py @@ -967,13 +967,12 @@ class Decimal(object): return self._cmp(other) >= 0 def compare(self, other, context=None): - """Compares one to another. + """Compare self to other. Return a decimal value: - -1 => a < b - 0 => a = b - 1 => a > b - NaN => one is NaN - Like __cmp__, but returns Decimal instances. + a or b is a NaN ==> Decimal('NaN') + a < b ==> Decimal('-1') + a == b ==> Decimal('0') + a > b ==> Decimal('1') """ other = _convert_other(other, raiseit=True) diff --git a/Lib/sqlite3/test/types.py b/Lib/sqlite3/test/types.py index a8fdad9ee13..adad571b9a0 100644 --- a/Lib/sqlite3/test/types.py +++ b/Lib/sqlite3/test/types.py @@ -88,19 +88,10 @@ class DeclTypesTests(unittest.TestCase): _val = _val.decode('utf-8') self.val = _val - def __cmp__(self, other): - if not isinstance(other, DeclTypesTests.Foo): - raise ValueError - if self.val == other.val: - return 0 - else: - return 1 - def __eq__(self, other): - c = self.__cmp__(other) - if c is NotImplemented: - return c - return c == 0 + if not isinstance(other, DeclTypesTests.Foo): + return NotImplemented + return self.val == other.val def __conform__(self, protocol): if protocol is sqlite.PrepareProtocol: diff --git a/Lib/test/mapping_tests.py b/Lib/test/mapping_tests.py index bc12c7756f2..ff82f4eb7d8 100644 --- a/Lib/test/mapping_tests.py +++ b/Lib/test/mapping_tests.py @@ -64,7 +64,7 @@ class BasicTestMappingProtocol(unittest.TestCase): self.assertEqual(d, d) self.assertNotEqual(p, d) self.assertNotEqual(d, p) - #__non__zero__ + #bool if p: self.fail("Empty mapping must compare to False") if not d: self.fail("Full mapping must compare to True") # keys(), items(), iterkeys() ... diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py index 93f9dae2151..e1765f0d5a5 100644 --- a/Lib/test/test_abc.py +++ b/Lib/test/test_abc.py @@ -194,9 +194,9 @@ class TestABC(unittest.TestCase): # check that the property's __isabstractmethod__ descriptor does the # right thing when presented with a value that fails truth testing: class NotBool(object): - def __nonzero__(self): + def __bool__(self): raise ValueError() - __len__ = __nonzero__ + __len__ = __bool__ with self.assertRaises(ValueError): class F(C): def bar(self): diff --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py index 9a59c58ec06..0e75c6bd329 100644 --- a/Lib/test/test_augassign.py +++ b/Lib/test/test_augassign.py @@ -136,14 +136,6 @@ class AugAssignTest(unittest.TestCase): output.append("__imul__ called") return self - def __div__(self, val): - output.append("__div__ called") - def __rdiv__(self, val): - output.append("__rdiv__ called") - def __idiv__(self, val): - output.append("__idiv__ called") - return self - def __floordiv__(self, val): output.append("__floordiv__ called") return self diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py index c7003fbe608..e3883d67b76 100644 --- a/Lib/test/test_class.py +++ b/Lib/test/test_class.py @@ -15,6 +15,8 @@ testmeths = [ "rmul", "truediv", "rtruediv", + "floordiv", + "rfloordiv", "mod", "rmod", "divmod", @@ -174,15 +176,23 @@ class ClassTests(unittest.TestCase): 1 * testme self.assertCallStack([("__rmul__", (testme, 1))]) - if 1/2 == 0: - callLst[:] = [] - testme / 1 - self.assertCallStack([("__div__", (testme, 1))]) + callLst[:] = [] + testme / 1 + self.assertCallStack([("__truediv__", (testme, 1))]) - callLst[:] = [] - 1 / testme - self.assertCallStack([("__rdiv__", (testme, 1))]) + callLst[:] = [] + 1 / testme + self.assertCallStack([("__rtruediv__", (testme, 1))]) + + callLst[:] = [] + testme // 1 + self.assertCallStack([("__floordiv__", (testme, 1))]) + + + callLst[:] = [] + 1 // testme + self.assertCallStack([("__rfloordiv__", (testme, 1))]) callLst[:] = [] testme % 1 @@ -444,12 +454,16 @@ class ClassTests(unittest.TestCase): def __int__(self): return None __float__ = __int__ + __complex__ = __int__ __str__ = __int__ __repr__ = __int__ - __oct__ = __int__ - __hex__ = __int__ + __bytes__ = __int__ + __bool__ = __int__ + __index__ = __int__ + def index(x): + return [][x] - for f in [int, float, str, repr, oct, hex]: + for f in [float, complex, str, repr, bytes, bin, oct, hex, bool, index]: self.assertRaises(TypeError, f, BadTypeClass()) def testHashStuff(self): diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py index 1de2a992e6b..9a60a12c298 100644 --- a/Lib/test/test_descr.py +++ b/Lib/test/test_descr.py @@ -21,7 +21,8 @@ class OperatorsTest(unittest.TestCase): 'add': '+', 'sub': '-', 'mul': '*', - 'div': '/', + 'truediv': '/', + 'floordiv': '//', 'divmod': 'divmod', 'pow': '**', 'lshift': '<<', @@ -52,8 +53,6 @@ class OperatorsTest(unittest.TestCase): 'invert': '~', 'int': 'int', 'float': 'float', - 'oct': 'oct', - 'hex': 'hex', } for name, expr in list(self.unops.items()): @@ -82,12 +81,6 @@ class OperatorsTest(unittest.TestCase): def binop_test(self, a, b, res, expr="a+b", meth="__add__"): d = {'a': a, 'b': b} - # XXX Hack so this passes before 2.3 when -Qnew is specified. - if meth == "__div__" and 1/2 == 0.5: - meth = "__truediv__" - - if meth == '__divmod__': pass - self.assertEqual(eval(expr, d), res) t = type(a) m = getattr(t, meth) @@ -221,7 +214,7 @@ class OperatorsTest(unittest.TestCase): def number_operators(self, a, b, skip=[]): dict = {'a': a, 'b': b} - for name, expr in list(self.binops.items()): + for name, expr in self.binops.items(): if name not in skip: name = "__%s__" % name if hasattr(a, name): @@ -261,7 +254,7 @@ class OperatorsTest(unittest.TestCase): # Testing complex operations... self.number_operators(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge', 'int', 'float', - 'divmod', 'mod']) + 'floordiv', 'divmod', 'mod']) class Number(complex): __slots__ = ['prec'] @@ -4160,9 +4153,8 @@ order (MRO) for bases """ ('__add__', 'x + y', 'x += y'), ('__sub__', 'x - y', 'x -= y'), ('__mul__', 'x * y', 'x *= y'), - ('__truediv__', 'operator.truediv(x, y)', None), - ('__floordiv__', 'operator.floordiv(x, y)', None), - ('__div__', 'x / y', 'x /= y'), + ('__truediv__', 'x / y', 'x /= y'), + ('__floordiv__', 'x // y', 'x //= y'), ('__mod__', 'x % y', 'x %= y'), ('__divmod__', 'divmod(x, y)', None), ('__pow__', 'x ** y', 'x **= y'), @@ -4224,8 +4216,8 @@ order (MRO) for bases """ # Also check type_getattro for correctness. class Meta(type): pass - class X(object): - __metaclass__ = Meta + class X(metaclass=Meta): + pass X.a = 42 Meta.a = Descr("a") self.assertEqual(X.a, 42) diff --git a/Lib/test/test_dynamicclassattribute.py b/Lib/test/test_dynamicclassattribute.py index 079d6c32241..bc6a39bb376 100644 --- a/Lib/test/test_dynamicclassattribute.py +++ b/Lib/test/test_dynamicclassattribute.py @@ -158,9 +158,9 @@ class PropertyTests(unittest.TestCase): # check that the DynamicClassAttribute's __isabstractmethod__ descriptor does the # right thing when presented with a value that fails truth testing: class NotBool(object): - def __nonzero__(self): + def __bool__(self): raise ValueError() - __len__ = __nonzero__ + __len__ = __bool__ with self.assertRaises(ValueError): class C(object): def foo(self): diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py index fc3bf07f1c0..a2bb9b6a2a7 100644 --- a/Lib/test/test_inspect.py +++ b/Lib/test/test_inspect.py @@ -786,7 +786,7 @@ class TestClassesAndFunctions(unittest.TestCase): class Meta(type): fish = 'slap' def __dir__(self): - return ['__class__', '__modules__', '__name__', 'fish'] + return ['__class__', '__module__', '__name__', 'fish'] class Class(metaclass=Meta): pass should_find = inspect.Attribute('fish', 'data', Meta, 'slap') diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index 244598b7529..eb51be4dbc8 100644 --- a/Lib/test/test_itertools.py +++ b/Lib/test/test_itertools.py @@ -698,7 +698,7 @@ class TestBasicOps(unittest.TestCase): # iter.__next__ failure on inner object self.assertRaises(ExpectedError, gulp, delayed_raise(1)) - # __cmp__ failure + # __eq__ failure class DummyCmp: def __eq__(self, dst): raise ExpectedError diff --git a/Lib/test/test_property.py b/Lib/test/test_property.py index 96eeb88b893..cee7203d152 100644 --- a/Lib/test/test_property.py +++ b/Lib/test/test_property.py @@ -140,9 +140,9 @@ class PropertyTests(unittest.TestCase): # check that the property's __isabstractmethod__ descriptor does the # right thing when presented with a value that fails truth testing: class NotBool(object): - def __nonzero__(self): + def __bool__(self): raise ValueError() - __len__ = __nonzero__ + __len__ = __bool__ with self.assertRaises(ValueError): class C(object): def foo(self): diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py index 7735a6bbaa4..4f45d39a3c1 100644 --- a/Lib/test/test_unicode.py +++ b/Lib/test/test_unicode.py @@ -1988,64 +1988,26 @@ class UnicodeTest(string_tests.CommonTest, self.fail("Should have raised UnicodeDecodeError") def test_conversion(self): - # Make sure __unicode__() works properly - class Foo0: + # Make sure __str__() works properly + class ObjectToStr: def __str__(self): return "foo" - class Foo1: + class StrSubclassToStr(str): def __str__(self): return "foo" - class Foo2(object): - def __str__(self): - return "foo" - - class Foo3(object): - def __str__(self): - return "foo" - - class Foo4(str): - def __str__(self): - return "foo" - - class Foo5(str): - def __str__(self): - return "foo" - - class Foo6(str): - def __str__(self): - return "foos" - - def __str__(self): - return "foou" - - class Foo7(str): - def __str__(self): - return "foos" - def __str__(self): - return "foou" - - class Foo8(str): + class StrSubclassToStrSubclass(str): def __new__(cls, content=""): return str.__new__(cls, 2*content) def __str__(self): return self - class Foo9(str): - def __str__(self): - return "not unicode" - - self.assertEqual(str(Foo0()), "foo") - self.assertEqual(str(Foo1()), "foo") - self.assertEqual(str(Foo2()), "foo") - self.assertEqual(str(Foo3()), "foo") - self.assertEqual(str(Foo4("bar")), "foo") - self.assertEqual(str(Foo5("bar")), "foo") - self.assertEqual(str(Foo6("bar")), "foou") - self.assertEqual(str(Foo7("bar")), "foou") - self.assertEqual(str(Foo8("foo")), "foofoo") - self.assertEqual(str(Foo9("foo")), "not unicode") + self.assertEqual(str(ObjectToStr()), "foo") + self.assertEqual(str(StrSubclassToStr("bar")), "foo") + s = str(StrSubclassToStrSubclass("foo")) + self.assertEqual(s, "foofoo") + self.assertIs(type(s), StrSubclassToStrSubclass) def test_unicode_repr(self): class s1: diff --git a/Modules/_decimal/tests/deccheck.py b/Modules/_decimal/tests/deccheck.py index c4c5a4461d5..27137b2e49e 100644 --- a/Modules/_decimal/tests/deccheck.py +++ b/Modules/_decimal/tests/deccheck.py @@ -126,7 +126,7 @@ ContextFunctions = { # Functions that require a restricted exponent range for reasonable runtimes. UnaryRestricted = [ - '__ceil__', '__floor__', '__int__', '__long__', '__trunc__', + '__ceil__', '__floor__', '__int__', '__trunc__', 'to_integral', 'to_integral_value' ] diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c index 910d5ea57de..243e2a333bc 100644 --- a/Modules/mathmodule.c +++ b/Modules/mathmodule.c @@ -992,7 +992,7 @@ FUNC1(tanh, tanh, 0, Note 4: A similar implementation is in Modules/cmathmodule.c. Be sure to update both when making changes. - Note 5: The signature of math.fsum() differs from __builtin__.sum() + Note 5: The signature of math.fsum() differs from builtins.sum() because the start argument doesn't make sense in the context of accurate summation. Since the partials table is collapsed before returning a result, sum(seq2, start=sum(seq1)) may not equal the diff --git a/Tools/clinic/clinic.py b/Tools/clinic/clinic.py index 65bad5174cc..5dcaa93246f 100755 --- a/Tools/clinic/clinic.py +++ b/Tools/clinic/clinic.py @@ -1830,7 +1830,6 @@ __gt__ __hash__ __iadd__ __iand__ -__idivmod__ __ifloordiv__ __ilshift__ __imod__ diff --git a/Tools/pynche/ColorDB.py b/Tools/pynche/ColorDB.py index fcf1b87cd27..5ced0e71b54 100644 --- a/Tools/pynche/ColorDB.py +++ b/Tools/pynche/ColorDB.py @@ -23,7 +23,6 @@ color formats, and for calculating other color values. import sys import re from types import * -import operator class BadColor(Exception): pass @@ -230,9 +229,8 @@ def triplet_to_rrggbb(rgbtuple): return hexname -_maxtuple = (256.0,) * 3 def triplet_to_fractional_rgb(rgbtuple): - return list(map(operator.__div__, rgbtuple, _maxtuple)) + return [x / 256 for x in rgbtuple] def triplet_to_brightness(rgbtuple):