Treat a torch that fails with an ImportError as missing, as before

When importing torch raised an ImportError, for example because one of its
shared libraries is missing, the bindings used to return ExecuTorchResult
outputs, as if torch were not installed. When the torch import moved to
the first call that needs it, only a ModuleNotFoundError for torch itself
counted as missing, so such a torch made every call raise. That was the
only change in output type that had no warning period.

Count every ImportError as missing again, so these setups keep working as
they did. Any other error from importing torch is still raised, with a note
on how to run without it.

Author: shoumikhin

docs/source/runtime-python-api-reference.rst

@@ -46,7 +46,7 @@ For data on a GPU, use DLPack, the standard way to share tensors between Python
 Output types
 ~~~~~~~~~~~~
 
-Importing ``executorch.runtime`` does not import PyTorch, unless the setting below asks for ``torch``. When PyTorch is installed, ``Method.execute`` returns ``torch.Tensor`` outputs, and the first call that returns one imports ``torch``. Without PyTorch, it returns ``ExecuTorchResult`` outputs. If PyTorch is installed but fails to import, every call that returns a tensor raises the import error; set the setting below to ``executorch`` to run without PyTorch.
+Importing ``executorch.runtime`` does not import PyTorch, unless the setting below asks for ``torch``. When PyTorch is installed, ``Method.execute`` returns ``torch.Tensor`` outputs, and the first call that returns one imports ``torch``. Without PyTorch, or when importing it raises an ``ImportError``, it returns ``ExecuTorchResult`` outputs. Any other error from importing PyTorch is raised by every call that returns a tensor; set the setting below to ``executorch`` to run without PyTorch.
 
 A future release will make the outputs follow the tensor inputs of each call. A call with any ``torch.Tensor`` input will return ``torch.Tensor`` outputs. A call whose tensor inputs are all NumPy arrays, other buffers, DLPack objects, or ``ExecuTorchResult`` values will return ``ExecuTorchResult`` outputs, even when PyTorch is installed. A call with no tensor inputs will return ``torch.Tensor`` outputs only if ``torch`` is already imported. Each call whose outputs will change warns with a ``FutureWarning``.
 

extension/pybindings/README.md

@@ -44,11 +44,11 @@ the same for its outputs.
 Unless `EXECUTORCH_PYBINDINGS_TENSOR_OUTPUT` is `torch`, importing
 `portable_lib` does not import PyTorch. When PyTorch is installed, portable
 bindings return `torch.Tensor` outputs, and the first call that returns one
-imports `torch`. When PyTorch is not installed, outputs are `ExecuTorchResult`
-values. When it is installed but fails to import, every call that returns a
-tensor raises the import error; set the variable to `executorch` to run
-without PyTorch. Output conversion uses Python APIs and DLPack; the extension
-does not link against PyTorch.
+imports `torch`. When PyTorch is not installed, or importing it raises an
+`ImportError`, outputs are `ExecuTorchResult` values. Any other error from
+importing it is raised by every call that returns a tensor; set the variable
+to `executorch` to run without PyTorch. Output conversion uses Python APIs and
+DLPack; the extension does not link against PyTorch.
 `clone_outputs=True` returns storage that later executions do not overwrite,
 on the output's original device. With `clone_outputs=False`, results share
 runtime or input storage and later execution may overwrite that storage.

extension/pybindings/pybindings.cpp

@@ -802,10 +802,10 @@ bool keep_torch_outputs() {
     try {
       py::module_::import("torch");
     } catch (py::error_already_set& error) {
-      // Only a torch that is not there counts as missing. A torch that is
-      // there but fails to import, even with an ImportError, is reported.
-      if (!error.matches(PyExc_ModuleNotFoundError) ||
-          py::str(error.value().attr("name")).cast<std::string>() != "torch") {
+      // As when torch was imported with ExecuTorch, a torch that fails with
+      // an ImportError, such as for a missing library, counts as missing.
+      // Any other error is reported.
+      if (!error.matches(PyExc_ImportError)) {
         try {
           error.value().attr("add_note")(
               "ExecuTorch imports torch here to return torch.Tensor outputs. "

extension/pybindings/test/test_pybindings.py

@@ -406,17 +406,12 @@ def run(index):
                 from executorch.extension.pybindings import portable_lib
 
                 module = portable_lib._load_for_executorch(program_path)
-                # A torch that is there but broken, even with an ImportError or
-                # a missing module of its own.
-                for error_type, missing in (
-                    (RuntimeError, "torch"),
-                    (ImportError, "torch"),
-                    (ModuleNotFoundError, "torch._C"),
-                ):
-                    blocker.error, blocker.missing = error_type, missing
+                # A torch that fails with an error other than ImportError is
+                # reported at every call.
+                for _ in range(2):
                     try:
                         module.forward([x, x])
-                    except error_type as error:
+                    except RuntimeError as error:
                         assert "torch is unavailable" in str(error), error
                         # add_note is new in Python 3.11.
                         notes = "".join(getattr(error, "__notes__", []))
@@ -425,11 +420,13 @@ def run(index):
                         ), notes
                     else:
                         raise AssertionError("a broken torch must not be hidden")
-                blocker.missing = "torch"
+                # An ImportError, even for a part of torch, counts as missing,
+                # as when torch was imported with ExecuTorch.
+                blocker.error, blocker.missing = ImportError, "torch._C"
                 check(lambda: module.forward([x, x]), ["ExecuTorchResult"])
                 check(lambda: module.run_method("tensor_constant"), ["ExecuTorchResult"])
                 # A missing torch is not looked for again on every call.
-                assert blocker.attempts == 4, blocker.attempts
+                assert blocker.attempts == 3, blocker.attempts
                 assert "torch" not in sys.modules
                 """,
             ),