Make bool(), int() and float() of an ExecuTorchResult raise TypeError

An ExecuTorchResult supports the buffer protocol but has no truth value or
number conversion of its own. So Python falls back to defaults that can give
wrong answers without an error: bool(result) is always True, and int() and
float() parse the raw bytes as text, so a uint8 result that holds 55 (the
character "7") gives 7.

Now all three raise TypeError and say how to convert the result first:

    bool(result)
    # TypeError: ExecuTorchResult has no truth value. Convert it first, for
    # example with numpy.asarray(result) or torch.from_dlpack(result).

Tested with the standalone no-ATen build: a new test checks that all three
raise TypeError, and it fails without this change.

Author: shoumikhin

extension/pybindings/README.md

@@ -103,7 +103,9 @@ from executorch.extension.pybindings import portable_lib
 ```
 
 `ExecuTorchResult` preserves shape, strides, dtype, and device. CPU results expose
-the Python buffer protocol so NumPy can read them without another copy. Without
+the Python buffer protocol so NumPy can read them without another copy. A result
+is not a number or a truth value: `bool()`, `int()`, and `float()` raise
+`TypeError`, so convert it first, for example with `np.asarray(output)`. Without
 the environment setting, the bindings fall back to `ExecuTorchResult` if
 PyTorch cannot be imported. Explicitly selecting `torch` requires it to import
 successfully. ATen-mode bindings continue to return native PyTorch tensors

extension/pybindings/pybindings.cpp

@@ -5447,6 +5447,15 @@ py::dict get_option(const std::string& backend_name, const py::dict& options) {
   return result;
 }
 
+auto refuse_scalar_conversion(const char* problem) {
+  return [problem](const PyExecuTorchResult&) -> py::object {
+    throw py::type_error(
+        std::string("ExecuTorchResult ") + problem +
+        ". Convert it first, for example with numpy.asarray(result) or "
+        "torch.from_dlpack(result).");
+  };
+}
+
 } // namespace
 
 PYBIND11_MODULE(EXECUTORCH_PYTHON_MODULE_NAME, m) {
@@ -5579,6 +5588,12 @@ PYBIND11_MODULE(EXECUTORCH_PYTHON_MODULE_NAME, m) {
           "Copy a dense CPU buffer, or a CPU ExecuTorchResult, to a CUDA "
           "device, for use as a method input. Requires bindings built with "
           "CUDA support.")
+      // Python would otherwise treat a result as always true, and int() and
+      // float() would parse its bytes as text.
+      .def("__bool__", refuse_scalar_conversion("has no truth value"))
+      .def("__int__", refuse_scalar_conversion("cannot be converted to int"))
+      .def(
+          "__float__", refuse_scalar_conversion("cannot be converted to float"))
       .def("__repr__", &PyExecuTorchResult::repr);
 #ifndef USE_ATEN_LIB
   py::class_<

extension/pybindings/test/test_pybindings_no_aten.py

@@ -211,6 +211,21 @@ def test_executorch_result_to_host_and_repr(self) -> None:
         self.assertFalse(np.shares_memory(np.asarray(copy), np.asarray(output)))
         np.testing.assert_array_equal(np.asarray(copy), np.array([3.0]))
 
+    def test_executorch_result_is_not_a_bool_or_number(self) -> None:
+        if runtime._tensor_output != "executorch":
+            self.skipTest("ExecuTorchResult output was not selected")
+        with open(os.environ["EXECUTORCH_PYBIND_TEST_PTE"], "rb") as program_file:
+            program_data = program_file.read()
+        module = runtime._load_for_executorch_from_buffer(program_data)
+        output = module(
+            (np.array([1.0], dtype=np.float32), np.array([2.0], dtype=np.float32))
+        )[0]
+
+        for convert in (bool, int, float):
+            with self.subTest(convert=convert.__name__):
+                with self.assertRaisesRegex(TypeError, r"numpy\.asarray\(result\)"):
+                    convert(output)
+
     def test_executorch_result_from_host_requires_cuda(self) -> None:
         # A build with CUDA support uploads instead; the CUDA suite covers it.
         if "CudaBackend" in runtime._get_registered_backend_names():