Fix OO operator protocols (NotImplemented, type checks, hash)

just_intonation.py

@@ -266,7 +266,6 @@ def __init__(self, numerator, denominator=None):
         g = _gcd(numerator, denominator)
         self._numerator = numerator // g
         self._denominator = denominator // g
-        self._terms = self._denominator, self._numerator
 
     @property
     def numerator(a):
@@ -414,6 +413,7 @@ def __add__(a, b):
         """
         if isinstance(b, Interval):
             return Interval(_F(a) * _F(b))
+        return NotImplemented
 
     def __sub__(a, b):
         """
@@ -422,6 +422,7 @@ def __sub__(a, b):
         """
         if isinstance(b, Interval):
             return Interval(_F(a) / _F(b))
+        return NotImplemented
 
     def __mul__(a, b):
         """
@@ -552,26 +553,33 @@ def __abs__(a):
 
     def __eq__(a, b):
         """a == b"""
-        if isinstance(b, Interval):
-            return (a._numerator == b.numerator and
-                    a._denominator == b.denominator)
-        else:
-            return False  # TODO: or NotImplemented??
+        if not isinstance(b, Interval):
+            return NotImplemented
+        return (a._numerator == b.numerator and
+                a._denominator == b.denominator)
 
     def __lt__(a, b):
         """a < b"""
+        if not isinstance(b, Interval):
+            return NotImplemented
         return _F(a) < _F(b)
 
     def __gt__(a, b):
         """a > b"""
+        if not isinstance(b, Interval):
+            return NotImplemented
         return _F(a) > _F(b)
 
     def __le__(a, b):
         """a <= b"""
+        if not isinstance(b, Interval):
+            return NotImplemented
         return _F(a) <= _F(b)
 
     def __ge__(a, b):
         """a >= b"""
+        if not isinstance(b, Interval):
+            return NotImplemented
         return _F(a) >= _F(b)
 
     def __bool__(a):
@@ -647,7 +655,7 @@ def __init__(self, frequency):
             self._frequency = Fraction(frequency)
 
         if int(self._frequency) == self._frequency:
-            self._frequency = int(frequency)
+            self._frequency = int(self._frequency)
 
         if self._frequency < 0:
             raise ValueError('Pitch frequency cannot be negative')
@@ -699,19 +707,27 @@ def __sub__(a, b):
 
     def __lt__(a, b):
         """a < b"""
-        return a._frequency < b.frequency
+        if not isinstance(b, Pitch):
+            return NotImplemented
+        return a._frequency < b._frequency
 
     def __gt__(a, b):
         """a > b"""
-        return a._frequency > b.frequency
+        if not isinstance(b, Pitch):
+            return NotImplemented
+        return a._frequency > b._frequency
 
     def __le__(a, b):
         """a <= b"""
-        return a._frequency <= b.frequency
+        if not isinstance(b, Pitch):
+            return NotImplemented
+        return a._frequency <= b._frequency
 
     def __ge__(a, b):
         """a >= b"""
-        return a._frequency >= b.frequency
+        if not isinstance(b, Pitch):
+            return NotImplemented
+        return a._frequency >= b._frequency
 
     def __bool__(a):
         """a != 0"""
@@ -723,7 +739,12 @@ def __neg__(a):
 
     def __eq__(a, b):
         """a == b"""
-        return (a._frequency == b.frequency)
+        if not isinstance(b, Pitch):
+            return NotImplemented
+        return a._frequency == b._frequency
+
+    def __hash__(self):
+        return hash(self._frequency)
 
     def __int__(a):
         """int(a)"""
@@ -734,7 +755,7 @@ def __float__(a):
         return float(a._frequency)
 
 
-class Chord():
+class Chord:
     """
     A combination of notes separated by just intervals.
 
@@ -1069,8 +1090,12 @@ def __eq__(a, b):
         >>> Chord(4, 6, 8) == Chord(2, 3, 4)
         True
         """
-        # TODO: is this ok?  or only public properties?
-        return (a._terms == b._terms)
+        if not isinstance(b, Chord):
+            return NotImplemented
+        return a._terms == b._terms
+
+    def __hash__(self):
+        return hash(self._terms)
 
     def __neg__(a):
         """

test_just_intonation.py

@@ -355,7 +355,7 @@ def test_chord():
     assert Chord(Interval('3:2'), Interval(2)) == Chord(2, 3, 4)
     assert Chord(Interval('M3'), Interval('m3')) == Chord(20, 24, 25)
     assert Chord(M3) == Chord(4, 5)
-    assert Chord(M3) == Interval(5, 4)  # Is this ok?
+    assert Chord(M3) != Interval(5, 4)
     assert Chord(M3, m3) == Chord(20, 24, 25)
     assert Chord(M3, P5) == Chord(4, 5, 6)
     assert Chord(P5, M3) == Chord(4, 5, 6)