🤖 generate scalar binop tests for __eq__

Author: jorenham

test/generate_scalar_binops.py

@@ -33,8 +33,7 @@
     "<=": op.__le__,
     ">=": op.__ge__,
     ">": op.__gt__,
-    # TODO(jorenham): these currently all return `Any`; fix this
-    # "==": op.__eq__,
+    "==": op.__eq__,
 }
 NAMES = {
     # builtins (key length > 1)
@@ -132,8 +131,12 @@ def _assert_stmt(op: str, lhs: str, rhs: str, /) -> str | None:
             "# pyright: ignore[reportOperatorIssue]",
         ))
 
-    expr_type = _sctype_expr(val_out.dtype)
-    return f"assert_type({expr_eval}, {expr_type})"
+    expr_type = (
+        _sctype_expr(val_out.dtype)
+        if isinstance(val_out, np.generic)
+        else type(val_out).__qualname__
+    )
+    return f"assert_type({expr_eval}, {expr_type})" if expr_type != "bool" else None
 
 
 def _gen_imports() -> Generator[str]:

test/generated/scalar_binops.pyi

@@ -1,4 +1,4 @@
-# @generated 2025-03-06T18:23:22Z
+# @generated 2025-03-06T21:57:19Z
 from typing_extensions import assert_type
 
 import numpy as np
@@ -4094,3 +4094,315 @@ assert_type(m8 > i8, np.bool)
 assert_type(m8 > m8, np.bool)
 
 assert_type(M8 > M8, np.bool)
+
+###
+# __[r]eq__
+
+assert_type(b1 == b0, np.bool)
+assert_type(b1 == b1, np.bool)
+assert_type(b1 == u1, np.bool)
+assert_type(b1 == u2, np.bool)
+assert_type(b1 == u4, np.bool)
+assert_type(b1 == u8, np.bool)
+assert_type(b1 == i1, np.bool)
+assert_type(b1 == i2, np.bool)
+assert_type(b1 == i4, np.bool)
+assert_type(b1 == i8, np.bool)
+assert_type(b1 == f2, np.bool)
+assert_type(b1 == f4, np.bool)
+assert_type(b1 == f8, np.bool)
+assert_type(b1 == ld, np.bool)
+assert_type(b1 == c8, np.bool)
+assert_type(b1 == c16, np.bool)
+assert_type(b1 == cld, np.bool)
+assert_type(b1 == m8, np.bool)
+
+assert_type(u1 == b0, np.bool)
+assert_type(u1 == b1, np.bool)
+assert_type(u1 == u1, np.bool)
+assert_type(u1 == u2, np.bool)
+assert_type(u1 == u4, np.bool)
+assert_type(u1 == u8, np.bool)
+assert_type(u1 == i1, np.bool)
+assert_type(u1 == i2, np.bool)
+assert_type(u1 == i4, np.bool)
+assert_type(u1 == i8, np.bool)
+assert_type(u1 == f2, np.bool)
+assert_type(u1 == f4, np.bool)
+assert_type(u1 == f8, np.bool)
+assert_type(u1 == ld, np.bool)
+assert_type(u1 == c8, np.bool)
+assert_type(u1 == c16, np.bool)
+assert_type(u1 == cld, np.bool)
+assert_type(u1 == m8, np.bool)
+
+assert_type(u2 == b0, np.bool)
+assert_type(u2 == b1, np.bool)
+assert_type(u2 == u1, np.bool)
+assert_type(u2 == u2, np.bool)
+assert_type(u2 == u4, np.bool)
+assert_type(u2 == u8, np.bool)
+assert_type(u2 == i1, np.bool)
+assert_type(u2 == i2, np.bool)
+assert_type(u2 == i4, np.bool)
+assert_type(u2 == i8, np.bool)
+assert_type(u2 == f2, np.bool)
+assert_type(u2 == f4, np.bool)
+assert_type(u2 == f8, np.bool)
+assert_type(u2 == ld, np.bool)
+assert_type(u2 == c8, np.bool)
+assert_type(u2 == c16, np.bool)
+assert_type(u2 == cld, np.bool)
+assert_type(u2 == m8, np.bool)
+
+assert_type(u4 == b0, np.bool)
+assert_type(u4 == b1, np.bool)
+assert_type(u4 == u1, np.bool)
+assert_type(u4 == u2, np.bool)
+assert_type(u4 == u4, np.bool)
+assert_type(u4 == u8, np.bool)
+assert_type(u4 == i1, np.bool)
+assert_type(u4 == i2, np.bool)
+assert_type(u4 == i4, np.bool)
+assert_type(u4 == i8, np.bool)
+assert_type(u4 == f2, np.bool)
+assert_type(u4 == f4, np.bool)
+assert_type(u4 == f8, np.bool)
+assert_type(u4 == ld, np.bool)
+assert_type(u4 == c8, np.bool)
+assert_type(u4 == c16, np.bool)
+assert_type(u4 == cld, np.bool)
+assert_type(u4 == m8, np.bool)
+
+assert_type(u8 == b0, np.bool)
+assert_type(u8 == b1, np.bool)
+assert_type(u8 == u1, np.bool)
+assert_type(u8 == u2, np.bool)
+assert_type(u8 == u4, np.bool)
+assert_type(u8 == u8, np.bool)
+assert_type(u8 == i1, np.bool)
+assert_type(u8 == i2, np.bool)
+assert_type(u8 == i4, np.bool)
+assert_type(u8 == i8, np.bool)
+assert_type(u8 == f2, np.bool)
+assert_type(u8 == f4, np.bool)
+assert_type(u8 == f8, np.bool)
+assert_type(u8 == ld, np.bool)
+assert_type(u8 == c8, np.bool)
+assert_type(u8 == c16, np.bool)
+assert_type(u8 == cld, np.bool)
+
+assert_type(i1 == b0, np.bool)
+assert_type(i1 == b1, np.bool)
+assert_type(i1 == u1, np.bool)
+assert_type(i1 == u2, np.bool)
+assert_type(i1 == u4, np.bool)
+assert_type(i1 == u8, np.bool)
+assert_type(i1 == i1, np.bool)
+assert_type(i1 == i2, np.bool)
+assert_type(i1 == i4, np.bool)
+assert_type(i1 == i8, np.bool)
+assert_type(i1 == f2, np.bool)
+assert_type(i1 == f4, np.bool)
+assert_type(i1 == f8, np.bool)
+assert_type(i1 == ld, np.bool)
+assert_type(i1 == c8, np.bool)
+assert_type(i1 == c16, np.bool)
+assert_type(i1 == cld, np.bool)
+assert_type(i1 == m8, np.bool)
+
+assert_type(i2 == b0, np.bool)
+assert_type(i2 == b1, np.bool)
+assert_type(i2 == u1, np.bool)
+assert_type(i2 == u2, np.bool)
+assert_type(i2 == u4, np.bool)
+assert_type(i2 == u8, np.bool)
+assert_type(i2 == i1, np.bool)
+assert_type(i2 == i2, np.bool)
+assert_type(i2 == i4, np.bool)
+assert_type(i2 == i8, np.bool)
+assert_type(i2 == f2, np.bool)
+assert_type(i2 == f4, np.bool)
+assert_type(i2 == f8, np.bool)
+assert_type(i2 == ld, np.bool)
+assert_type(i2 == c8, np.bool)
+assert_type(i2 == c16, np.bool)
+assert_type(i2 == cld, np.bool)
+assert_type(i2 == m8, np.bool)
+
+assert_type(i4 == b0, np.bool)
+assert_type(i4 == b1, np.bool)
+assert_type(i4 == u1, np.bool)
+assert_type(i4 == u2, np.bool)
+assert_type(i4 == u4, np.bool)
+assert_type(i4 == u8, np.bool)
+assert_type(i4 == i1, np.bool)
+assert_type(i4 == i2, np.bool)
+assert_type(i4 == i4, np.bool)
+assert_type(i4 == i8, np.bool)
+assert_type(i4 == f2, np.bool)
+assert_type(i4 == f4, np.bool)
+assert_type(i4 == f8, np.bool)
+assert_type(i4 == ld, np.bool)
+assert_type(i4 == c8, np.bool)
+assert_type(i4 == c16, np.bool)
+assert_type(i4 == cld, np.bool)
+assert_type(i4 == m8, np.bool)
+
+assert_type(i8 == b0, np.bool)
+assert_type(i8 == b1, np.bool)
+assert_type(i8 == u1, np.bool)
+assert_type(i8 == u2, np.bool)
+assert_type(i8 == u4, np.bool)
+assert_type(i8 == u8, np.bool)
+assert_type(i8 == i1, np.bool)
+assert_type(i8 == i2, np.bool)
+assert_type(i8 == i4, np.bool)
+assert_type(i8 == i8, np.bool)
+assert_type(i8 == f2, np.bool)
+assert_type(i8 == f4, np.bool)
+assert_type(i8 == f8, np.bool)
+assert_type(i8 == ld, np.bool)
+assert_type(i8 == c8, np.bool)
+assert_type(i8 == c16, np.bool)
+assert_type(i8 == cld, np.bool)
+assert_type(i8 == m8, np.bool)
+
+assert_type(f2 == b0, np.bool)
+assert_type(f2 == b1, np.bool)
+assert_type(f2 == u1, np.bool)
+assert_type(f2 == u2, np.bool)
+assert_type(f2 == u4, np.bool)
+assert_type(f2 == u8, np.bool)
+assert_type(f2 == i1, np.bool)
+assert_type(f2 == i2, np.bool)
+assert_type(f2 == i4, np.bool)
+assert_type(f2 == i8, np.bool)
+assert_type(f2 == f2, np.bool)
+assert_type(f2 == f4, np.bool)
+assert_type(f2 == f8, np.bool)
+assert_type(f2 == ld, np.bool)
+assert_type(f2 == c8, np.bool)
+assert_type(f2 == c16, np.bool)
+assert_type(f2 == cld, np.bool)
+
+assert_type(f4 == b0, np.bool)
+assert_type(f4 == b1, np.bool)
+assert_type(f4 == u1, np.bool)
+assert_type(f4 == u2, np.bool)
+assert_type(f4 == u4, np.bool)
+assert_type(f4 == u8, np.bool)
+assert_type(f4 == i1, np.bool)
+assert_type(f4 == i2, np.bool)
+assert_type(f4 == i4, np.bool)
+assert_type(f4 == i8, np.bool)
+assert_type(f4 == f2, np.bool)
+assert_type(f4 == f4, np.bool)
+assert_type(f4 == f8, np.bool)
+assert_type(f4 == ld, np.bool)
+assert_type(f4 == c8, np.bool)
+assert_type(f4 == c16, np.bool)
+assert_type(f4 == cld, np.bool)
+
+assert_type(f8 == b0, np.bool)
+assert_type(f8 == b1, np.bool)
+assert_type(f8 == u1, np.bool)
+assert_type(f8 == u2, np.bool)
+assert_type(f8 == u4, np.bool)
+assert_type(f8 == u8, np.bool)
+assert_type(f8 == i1, np.bool)
+assert_type(f8 == i2, np.bool)
+assert_type(f8 == i4, np.bool)
+assert_type(f8 == i8, np.bool)
+assert_type(f8 == f2, np.bool)
+assert_type(f8 == f4, np.bool)
+assert_type(f8 == f8, np.bool)
+assert_type(f8 == ld, np.bool)
+assert_type(f8 == c8, np.bool)
+assert_type(f8 == c16, np.bool)
+assert_type(f8 == cld, np.bool)
+
+assert_type(ld == b0, np.bool)
+assert_type(ld == b1, np.bool)
+assert_type(ld == u1, np.bool)
+assert_type(ld == u2, np.bool)
+assert_type(ld == u4, np.bool)
+assert_type(ld == u8, np.bool)
+assert_type(ld == i1, np.bool)
+assert_type(ld == i2, np.bool)
+assert_type(ld == i4, np.bool)
+assert_type(ld == i8, np.bool)
+assert_type(ld == f2, np.bool)
+assert_type(ld == f4, np.bool)
+assert_type(ld == f8, np.bool)
+assert_type(ld == ld, np.bool)
+assert_type(ld == c8, np.bool)
+assert_type(ld == c16, np.bool)
+assert_type(ld == cld, np.bool)
+
+assert_type(c8 == b0, np.bool)
+assert_type(c8 == b1, np.bool)
+assert_type(c8 == u1, np.bool)
+assert_type(c8 == u2, np.bool)
+assert_type(c8 == u4, np.bool)
+assert_type(c8 == u8, np.bool)
+assert_type(c8 == i1, np.bool)
+assert_type(c8 == i2, np.bool)
+assert_type(c8 == i4, np.bool)
+assert_type(c8 == i8, np.bool)
+assert_type(c8 == f2, np.bool)
+assert_type(c8 == f4, np.bool)
+assert_type(c8 == f8, np.bool)
+assert_type(c8 == ld, np.bool)
+assert_type(c8 == c8, np.bool)
+assert_type(c8 == c16, np.bool)
+assert_type(c8 == cld, np.bool)
+
+assert_type(c16 == b0, np.bool)
+assert_type(c16 == b1, np.bool)
+assert_type(c16 == u1, np.bool)
+assert_type(c16 == u2, np.bool)
+assert_type(c16 == u4, np.bool)
+assert_type(c16 == u8, np.bool)
+assert_type(c16 == i1, np.bool)
+assert_type(c16 == i2, np.bool)
+assert_type(c16 == i4, np.bool)
+assert_type(c16 == i8, np.bool)
+assert_type(c16 == f2, np.bool)
+assert_type(c16 == f4, np.bool)
+assert_type(c16 == f8, np.bool)
+assert_type(c16 == ld, np.bool)
+assert_type(c16 == c8, np.bool)
+assert_type(c16 == c16, np.bool)
+assert_type(c16 == cld, np.bool)
+
+assert_type(cld == b0, np.bool)
+assert_type(cld == b1, np.bool)
+assert_type(cld == u1, np.bool)
+assert_type(cld == u2, np.bool)
+assert_type(cld == u4, np.bool)
+assert_type(cld == u8, np.bool)
+assert_type(cld == i1, np.bool)
+assert_type(cld == i2, np.bool)
+assert_type(cld == i4, np.bool)
+assert_type(cld == i8, np.bool)
+assert_type(cld == f2, np.bool)
+assert_type(cld == f4, np.bool)
+assert_type(cld == f8, np.bool)
+assert_type(cld == ld, np.bool)
+assert_type(cld == c8, np.bool)
+assert_type(cld == c16, np.bool)
+assert_type(cld == cld, np.bool)
+
+assert_type(m8 == b0, np.bool)
+assert_type(m8 == b1, np.bool)
+assert_type(m8 == u1, np.bool)
+assert_type(m8 == u2, np.bool)
+assert_type(m8 == u4, np.bool)
+assert_type(m8 == i1, np.bool)
+assert_type(m8 == i2, np.bool)
+assert_type(m8 == i4, np.bool)
+assert_type(m8 == i8, np.bool)
+assert_type(m8 == m8, np.bool)
+
+assert_type(M8 == M8, np.bool)