bpo-37685: Fixed __eq__, __lt__ etc implementations in some classes. (GH-14952)

They now return NotImplemented for unsupported type of the other operand.

Author: serhiy-storchaka

Lib/asyncio/events.py

@@ -119,20 +119,24 @@ def __hash__(self):
  return hash(self._when)
 
  def __lt__(self, other):
- return self._when < other._when
+ if isinstance(other, TimerHandle):
+ return self._when < other._when
+ return NotImplemented
 
  def __le__(self, other):
- if self._when < other._when:
- return True
- return self.__eq__(other)
+ if isinstance(other, TimerHandle):
+ return self._when < other._when or self.__eq__(other)
+ return NotImplemented
 
  def __gt__(self, other):
- return self._when > other._when
+ if isinstance(other, TimerHandle):
+ return self._when > other._when
+ return NotImplemented
 
  def __ge__(self, other):
- if self._when > other._when:
- return True
- return self.__eq__(other)
+ if isinstance(other, TimerHandle):
+ return self._when > other._when or self.__eq__(other)
+ return NotImplemented
 
  def __eq__(self, other):
  if isinstance(other, TimerHandle):
@@ -142,10 +146,6 @@ def __eq__(self, other):
  self._cancelled == other._cancelled)
  return NotImplemented
 
- def __ne__(self, other):
- equal = self.__eq__(other)
- return NotImplemented if equal is NotImplemented else not equal
-
  def cancel(self):
  if not self._cancelled:
  self._loop._timer_handle_cancelled(self)

Lib/distutils/tests/test_version.py

@@ -45,6 +45,14 @@ def test_cmp_strict(self):
  self.assertEqual(res, wanted,
  'cmp(%s, %s) should be %s, got %s' %
  (v1, v2, wanted, res))
+ res = StrictVersion(v1)._cmp(v2)
+ self.assertEqual(res, wanted,
+ 'cmp(%s, %s) should be %s, got %s' %
+ (v1, v2, wanted, res))
+ res = StrictVersion(v1)._cmp(object())
+ self.assertIs(res, NotImplemented,
+ 'cmp(%s, %s) should be NotImplemented, got %s' %
+ (v1, v2, res))
 
 
  def test_cmp(self):
@@ -63,6 +71,14 @@ def test_cmp(self):
  self.assertEqual(res, wanted,
  'cmp(%s, %s) should be %s, got %s' %
  (v1, v2, wanted, res))
+ res = LooseVersion(v1)._cmp(v2)
+ self.assertEqual(res, wanted,
+ 'cmp(%s, %s) should be %s, got %s' %
+ (v1, v2, wanted, res))
+ res = LooseVersion(v1)._cmp(object())
+ self.assertIs(res, NotImplemented,
+ 'cmp(%s, %s) should be NotImplemented, got %s' %
+ (v1, v2, res))
 
 def test_suite():
  return unittest.makeSuite(VersionTestCase)

Lib/distutils/version.py

@@ -166,6 +166,8 @@ def __str__ (self):
  def _cmp (self, other):
  if isinstance(other, str):
  other = StrictVersion(other)
+ elif not isinstance(other, StrictVersion):
+ return NotImplemented
 
  if self.version != other.version:
  # numeric versions don't match
@@ -331,6 +333,8 @@ def __repr__ (self):
  def _cmp (self, other):
  if isinstance(other, str):
  other = LooseVersion(other)
+ elif not isinstance(other, LooseVersion):
+ return NotImplemented
 
  if self.version == other.version:
  return 0

Lib/email/headerregistry.py

@@ -97,8 +97,8 @@ def __str__(self):
  return self.addr_spec
 
  def __eq__(self, other):
- if type(other) != type(self):
- return False
+ if not isinstance(other, Address):
+ return NotImplemented
  return (self.display_name == other.display_name and
  self.username == other.username and
  self.domain == other.domain)
@@ -150,8 +150,8 @@ def __str__(self):
  return "{}:{};".format(disp, adrstr)
 
  def __eq__(self, other):
- if type(other) != type(self):
- return False
+ if not isinstance(other, Group):
+ return NotImplemented
  return (self.display_name == other.display_name and
  self.addresses == other.addresses)
 

Lib/importlib/_bootstrap.py

@@ -371,7 +371,7 @@ def __eq__(self, other):
  self.cached == other.cached and
  self.has_location == other.has_location)
  except AttributeError:
- return False
+ return NotImplemented
 
  @property
  def cached(self):

Lib/test/test_asyncio/test_events.py

@@ -32,6 +32,7 @@
 from asyncio import selector_events
 from test.test_asyncio import utils as test_utils
 from test import support
+from test.support import ALWAYS_EQ, LARGEST, SMALLEST
 
 
 def tearDownModule():
@@ -2364,6 +2365,28 @@ def callback(*args):
  self.assertIs(NotImplemented, h1.__eq__(h3))
  self.assertIs(NotImplemented, h1.__ne__(h3))
 
+ with self.assertRaises(TypeError):
+ h1 < ()
+ with self.assertRaises(TypeError):
+ h1 > ()
+ with self.assertRaises(TypeError):
+ h1 <= ()
+ with self.assertRaises(TypeError):
+ h1 >= ()
+ self.assertFalse(h1 == ())
+ self.assertTrue(h1 != ())
+
+ self.assertTrue(h1 == ALWAYS_EQ)
+ self.assertFalse(h1 != ALWAYS_EQ)
+ self.assertTrue(h1 < LARGEST)
+ self.assertFalse(h1 > LARGEST)
+ self.assertTrue(h1 <= LARGEST)
+ self.assertFalse(h1 >= LARGEST)
+ self.assertFalse(h1 < SMALLEST)
+ self.assertTrue(h1 > SMALLEST)
+ self.assertFalse(h1 <= SMALLEST)
+ self.assertTrue(h1 >= SMALLEST)
+
 
 class AbstractEventLoopTests(unittest.TestCase):
 

Lib/test/test_email/test_headerregistry.py

@@ -7,6 +7,7 @@
 from test.test_email import TestEmailBase, parameterize
 from email import headerregistry
 from email.headerregistry import Address, Group
+from test.support import ALWAYS_EQ
 
 
 DITTO = object()
@@ -1525,6 +1526,24 @@ def test_set_message_header_from_group(self):
  self.assertEqual(m['to'], 'foo bar:;')
  self.assertEqual(m['to'].addresses, g.addresses)
 
+ def test_address_comparison(self):
+ a = Address('foo', 'bar', 'example.com')
+ self.assertEqual(Address('foo', 'bar', 'example.com'), a)
+ self.assertNotEqual(Address('baz', 'bar', 'example.com'), a)
+ self.assertNotEqual(Address('foo', 'baz', 'example.com'), a)
+ self.assertNotEqual(Address('foo', 'bar', 'baz'), a)
+ self.assertFalse(a == object())
+ self.assertTrue(a == ALWAYS_EQ)
+
+ def test_group_comparison(self):
+ a = Address('foo', 'bar', 'example.com')
+ g = Group('foo bar', [a])
+ self.assertEqual(Group('foo bar', (a,)), g)
+ self.assertNotEqual(Group('baz', [a]), g)
+ self.assertNotEqual(Group('foo bar', []), g)
+ self.assertFalse(g == object())
+ self.assertTrue(g == ALWAYS_EQ)
+
 
 class TestFolding(TestHeaderBase):
 

Lib/test/test_traceback.py

@@ -7,7 +7,7 @@
 import unittest
 import re
 from test import support
-from test.support import TESTFN, Error, captured_output, unlink, cpython_only
+from test.support import TESTFN, Error, captured_output, unlink, cpython_only, ALWAYS_EQ
 from test.support.script_helper import assert_python_ok
 import textwrap
 
@@ -887,6 +887,8 @@ def test_basics(self):
  # operator fallbacks to FrameSummary.__eq__.
  self.assertEqual(tuple(f), f)
  self.assertIsNone(f.locals)
+ self.assertNotEqual(f, object())
+ self.assertEqual(f, ALWAYS_EQ)
 
  def test_lazy_lines(self):
  linecache.clearcache()
@@ -1083,6 +1085,18 @@ def test_context(self):
  self.assertEqual(exc_info[0], exc.exc_type)
  self.assertEqual(str(exc_info[1]), str(exc))
 
+ def test_comparison(self):
+ try:
+ 1/0
+ except Exception:
+ exc_info = sys.exc_info()
+ exc = traceback.TracebackException(*exc_info)
+ exc2 = traceback.TracebackException(*exc_info)
+ self.assertIsNot(exc, exc2)
+ self.assertEqual(exc, exc2)
+ self.assertNotEqual(exc, object())
+ self.assertEqual(exc, ALWAYS_EQ)
+
  def test_unhashable(self):
  class UnhashableException(Exception):
  def __eq__(self, other):

Lib/test/test_weakref.py

@@ -11,7 +11,7 @@
 import random
 
 from test import support
-from test.support import script_helper
+from test.support import script_helper, ALWAYS_EQ
 
 # Used in ReferencesTestCase.test_ref_created_during_del() .
 ref_from_del = None
@@ -794,6 +794,10 @@ def test_equality(self):
  self.assertTrue(a != c)
  self.assertTrue(a == d)
  self.assertFalse(a != d)
+ self.assertFalse(a == x)
+ self.assertTrue(a != x)
+ self.assertTrue(a == ALWAYS_EQ)
+ self.assertFalse(a != ALWAYS_EQ)
  del x, y, z
  gc.collect()
  for r in a, b, c:
@@ -1102,6 +1106,9 @@ def _ne(a, b):
  _ne(a, f)
  _ne(b, e)
  _ne(b, f)
+ # Compare with different types
+ _ne(a, x.some_method)
+ _eq(a, ALWAYS_EQ)
  del x, y, z
  gc.collect()
  # Dead WeakMethods compare by identity

Lib/test/test_xmlrpc.py

@@ -15,6 +15,7 @@
 import io
 import contextlib
 from test import support
+from test.support import ALWAYS_EQ, LARGEST, SMALLEST
 
 try:
  import gzip
@@ -530,14 +531,10 @@ def test_comparison(self):
  # some other types
  dbytes = dstr.encode('ascii')
  dtuple = now.timetuple()
- with self.assertRaises(TypeError):
- dtime == 1970
- with self.assertRaises(TypeError):
- dtime != dbytes
- with self.assertRaises(TypeError):
- dtime == bytearray(dbytes)
- with self.assertRaises(TypeError):
- dtime != dtuple
+ self.assertFalse(dtime == 1970)
+ self.assertTrue(dtime != dbytes)
+ self.assertFalse(dtime == bytearray(dbytes))
+ self.assertTrue(dtime != dtuple)
  with self.assertRaises(TypeError):
  dtime < float(1970)
  with self.assertRaises(TypeError):
@@ -547,6 +544,18 @@ def test_comparison(self):
  with self.assertRaises(TypeError):
  dtime >= dtuple
 
+ self.assertTrue(dtime == ALWAYS_EQ)
+ self.assertFalse(dtime != ALWAYS_EQ)
+ self.assertTrue(dtime < LARGEST)
+ self.assertFalse(dtime > LARGEST)
+ self.assertTrue(dtime <= LARGEST)
+ self.assertFalse(dtime >= LARGEST)
+ self.assertFalse(dtime < SMALLEST)
+ self.assertTrue(dtime > SMALLEST)
+ self.assertFalse(dtime <= SMALLEST)
+ self.assertTrue(dtime >= SMALLEST)
+
+
 class BinaryTestCase(unittest.TestCase):
 
  # XXX What should str(Binary(b"\xff")) return? I'm chosing "\xff"