Annotate magic methods with predictable result types

Author: Sergey Vasilyev

data_diff/databases/base.py

@@ -895,7 +895,7 @@ class QueryResult:
     def __iter__(self):
         return iter(self.rows)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.rows)
 
     def __getitem__(self, i):

data_diff/lexicographic_space.py

@@ -70,7 +70,7 @@ def __init__(self, dims: Vector) -> None:
         super().__init__()
         self.dims = dims
 
-    def __contains__(self, v: Vector):
+    def __contains__(self, v: Vector) -> bool:
         return all(0 <= i < d for i, d in safezip(v, self.dims))
 
     def add(self, v1: Vector, v2: Vector) -> Vector:
@@ -138,7 +138,7 @@ def __init__(self, min_bound: Vector, max_bound: Vector) -> None:
 
         self.uspace = LexicographicSpace(dims)
 
-    def __contains__(self, p: Vector):
+    def __contains__(self, p: Vector) -> bool:
         return all(mn <= i < mx for i, mn, mx in safezip(p, self.min_bound, self.max_bound))
 
     def to_uspace(self, v: Vector) -> Vector:

data_diff/queries/base.py

@@ -5,7 +5,7 @@
 
 @attrs.define(frozen=True)
 class _SKIP:
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "SKIP"
 
 

data_diff/utils.py

@@ -161,7 +161,7 @@ def range(self, other: "ArithUUID", count: int) -> List[Self]:
         checkpoints = split_space(self.uuid.int, other.uuid.int, count)
         return [attrs.evolve(self, uuid=i) for i in checkpoints]
 
-    def __int__(self):
+    def __int__(self) -> int:
         return self.uuid.int
 
     def __add__(self, other: int) -> Self:
@@ -255,16 +255,16 @@ def __attrs_post_init__(self) -> None:
     # def int(self):
     #     return alphanumToNumber(self._str, alphanums)
 
-    def __str__(self):
+    def __str__(self) -> str:
         s = self._str
         if self._max_len:
             s = s.rjust(self._max_len, alphanums[0])
         return s
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._str)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'alphanum"{self._str}"'
 
     def __add__(self, other: "Union[ArithAlphanumeric, int]") -> Self:
@@ -289,17 +289,17 @@ def __sub__(self, other: "Union[ArithAlphanumeric, int]") -> float:
 
         return NotImplemented
 
-    def __ge__(self, other):
+    def __ge__(self, other) -> bool:
         if not isinstance(other, type(self)):
             return NotImplemented
         return self._str >= other._str
 
-    def __lt__(self, other):
+    def __lt__(self, other) -> bool:
         if not isinstance(other, type(self)):
             return NotImplemented
         return self._str < other._str
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         if not isinstance(other, type(self)):
             return NotImplemented
         return self._str == other._str
@@ -424,32 +424,32 @@ class Vector(tuple):
     Partial implementation: Only the needed functionality is implemented
     """
 
-    def __lt__(self, other: "Vector"):
+    def __lt__(self, other: "Vector") -> bool:
         if isinstance(other, Vector):
             return all(a < b for a, b in safezip(self, other))
         return NotImplemented
 
-    def __le__(self, other: "Vector"):
+    def __le__(self, other: "Vector") -> bool:
         if isinstance(other, Vector):
             return all(a <= b for a, b in safezip(self, other))
         return NotImplemented
 
-    def __gt__(self, other: "Vector"):
+    def __gt__(self, other: "Vector") -> bool:
         if isinstance(other, Vector):
             return all(a > b for a, b in safezip(self, other))
         return NotImplemented
 
-    def __ge__(self, other: "Vector"):
+    def __ge__(self, other: "Vector") -> bool:
         if isinstance(other, Vector):
             return all(a >= b for a, b in safezip(self, other))
         return NotImplemented
 
-    def __eq__(self, other: "Vector"):
+    def __eq__(self, other: "Vector") -> bool:
         if isinstance(other, Vector):
             return all(a == b for a, b in safezip(self, other))
         return NotImplemented
 
-    def __sub__(self, other: "Vector"):
+    def __sub__(self, other: "Vector") -> "Vector":
         if isinstance(other, Vector):
             return Vector((a - b) for a, b in safezip(self, other))
         raise NotImplementedError()
@@ -575,12 +575,12 @@ class UnknownMeta(type):
     def __instancecheck__(self, instance):
         return instance is Unknown
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "Unknown"
 
 
 class Unknown(metaclass=UnknownMeta):
-    def __nonzero__(self):
+    def __bool__(self) -> bool:
         raise TypeError()
 
     def __new__(class_, *args, **kwargs):

tests/test_database_types.py

@@ -407,7 +407,7 @@ def __iter__(self):
         step = timedelta(seconds=3, microseconds=571)
         return islice(chain(self.MANUAL_FAKES, accumulate(repeat(step), initial=initial)), self.max)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return self.max
 
 
@@ -423,7 +423,7 @@ def __iter__(self):
         step = 1
         return islice(chain(self.MANUAL_FAKES, accumulate(repeat(step), initial=initial)), self.max)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return self.max
 
 
@@ -437,7 +437,7 @@ def __init__(self, max) -> None:
     def __iter__(self):
         return iter(self.MANUAL_FAKES[: self.max])
 
-    def __len__(self):
+    def __len__(self) -> int:
         return min(self.max, len(self.MANUAL_FAKES))
 
 
@@ -470,7 +470,7 @@ def __iter__(self):
         step = 0.00571
         return islice(chain(self.MANUAL_FAKES, accumulate(repeat(step), initial=initial)), self.max)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return self.max
 
 
@@ -479,7 +479,7 @@ def __init__(self, max) -> None:
         super().__init__()
         self.max = max
 
-    def __len__(self):
+    def __len__(self) -> int:
         return self.max
 
     def __iter__(self):
@@ -498,7 +498,7 @@ def __init__(self, max) -> None:
     def __iter__(self):
         return iter(self.MANUAL_FAKES[: self.max])
 
-    def __len__(self):
+    def __len__(self) -> int:
         return min(self.max, len(self.MANUAL_FAKES))