traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Issue #23641: Cleaned out legacy dunder names from tests and docs. 

Fixed 2 to 3 porting bug in pynche.ColorDB.
Added few tests for __truediv__, __floordiv__ and __matmul__.
This commit is contained in:
Serhiy Storchaka 2015-03-12 22:01:30 +02:00
parent da0870c87a a60c2fe480
commit c2ccce791c
19 changed files with 86 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Doc/library/multiprocessing.rst
View File

@ -1834,7 +1834,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):

12
Doc/library/unittest.mock.rst
View File

@ -1621,19 +1621,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__``, ``__matmul__``, ``__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__``

11
Lib/_pydecimal.py
View File

@ -960,13 +960,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)

7
Lib/datetime.py
View File

@ -651,7 +651,7 @@ class date:
Operators:
__repr__, __str__
__cmp__, __hash__
__eq__, __le__, __lt__, __ge__, __gt__, __hash__
__add__, __radd__, __sub__ (add/radd only with timedelta arg)
Methods:
@ -786,7 +786,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()."
@ -1010,7 +1011,7 @@ class time:
Operators:
__repr__, __str__
__cmp__, __hash__
__eq__, __le__, __lt__, __ge__, __gt__, __hash__
Methods:

15
Lib/sqlite3/test/types.py
View File

@ -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:

2
Lib/test/mapping_tests.py
View File

@ -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() ...

4
Lib/test/test_abc.py
View File

@ -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):

8
Lib/test/test_augassign.py
View File

@ -144,14 +144,6 @@ class AugAssignTest(unittest.TestCase):
output.append("__imatmul__ 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

44
Lib/test/test_class.py
View File

@ -13,8 +13,12 @@ testmeths = [
"rsub",
"mul",
"rmul",
"matmul",
"rmatmul",
"truediv",
"rtruediv",
"floordiv",
"rfloordiv",
"mod",
"rmod",
"divmod",
@ -174,15 +178,31 @@ 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([("__matmul__", (testme, 1))])
callLst[:] = []
1 @ testme
self.assertCallStack([("__rmatmul__", (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 +464,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):

25
Lib/test/test_descr.py
View File

@ -21,7 +21,9 @@ class OperatorsTest(unittest.TestCase):
'add': '+',
'sub': '-',
'mul': '*',
'div': '/',
'matmul': '@',
'truediv': '/',
'floordiv': '//',
'divmod': 'divmod',
'pow': '**',
'lshift': '<<',
@ -52,8 +54,6 @@ class OperatorsTest(unittest.TestCase):
'invert': '~',
'int': 'int',
'float': 'float',
'oct': 'oct',
'hex': 'hex',
}
for name, expr in list(self.unops.items()):
@ -82,12 +82,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 +215,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 +255,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']
@ -4177,9 +4171,8 @@ order (MRO) for bases """
('__sub__', 'x - y', 'x -= y'),
('__mul__', 'x * y', 'x *= y'),
('__matmul__', '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'),
@ -4241,8 +4234,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)

4
Lib/test/test_dynamicclassattribute.py
View File

@ -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):

2
Lib/test/test_inspect.py
View File

@ -800,7 +800,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')

2
Lib/test/test_itertools.py
View File

@ -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

4
Lib/test/test_property.py
View File

@ -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):

56
Lib/test/test_unicode.py
View File

@ -2017,64 +2017,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:

2
Modules/_decimal/tests/deccheck.py
View File

@ -127,7 +127,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'
]

2
Modules/mathmodule.c
View File

@ -1021,7 +1021,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

4
Tools/clinic/clinic.py
View File

@ -1831,9 +1831,9 @@ __gt__
__hash__
__iadd__
__iand__
__idivmod__
__ifloordiv__
__ilshift__
__imatmul__
__imod__
__imul__
__index__
@ -1850,6 +1850,7 @@ __le__
__len__
__lshift__
__lt__
__matmul__
__mod__
__mul__
__neg__
@ -1864,6 +1865,7 @@ __rdivmod__
__repr__
__rfloordiv__
__rlshift__
__rmatmul__
__rmod__
__rmul__
__ror__

4
Tools/pynche/ColorDB.py
View File

@ -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):