Revert "[ONNX] Fix type annotations and enable type checking for all apis (pytorch#84091)"

This reverts commit 6446da1.

Reverted pytorch#84091 on behalf of https://github.com/facebook-github-bot due to Diff reverted internally

Author: pytorchmergebot

test/onnx/test_pytorch_onnx_onnxruntime.py

@@ -3582,7 +3582,7 @@ def forward(self, x, k):
 
         x = torch.arange(1.0, 6.0, requires_grad=True)
         k = torch.tensor(3)
-        self.run_test(MyModuleDynamic(), (x, k))
+        self.run_test(MyModuleDynamic(), [x, k])
 
     @skipScriptTest()  # Python builtin apply of FunctionMeta object is currently not supported in Torchscript.
     @skipIfUnsupportedMinOpsetVersion(11)  # Clip op min is an input since opset 11.
@@ -7396,28 +7396,23 @@ def test_constant_pad(self):
         x = torch.randn(2, 2, 4, 4)
         self.run_test(model, x)
 
-    @common_utils.parametrize(
-        "pad",
-        [
-            common_utils.subtest([2, 4], name="scalar_list"),
-            common_utils.subtest(
-                [
-                    torch.tensor(2, dtype=torch.int64),
-                    torch.tensor(4, dtype=torch.int64),
-                ],
-                name="scalar_tensor_list",
-            ),
-        ],
-    )
-    @skipIfUnsupportedMinOpsetVersion(11)  # Dynamic padding is added in opset 11
-    def test_pad_types(self, pad):
+    # Dynamic padding is added in opset 11
+    @skipIfUnsupportedMinOpsetVersion(11)
+    def test_pad_types(self):
         # Test for different pad integer types
         class Pad(torch.nn.Module):
             def forward(self, x, pad: List[int]):
                 return torch.nn.functional.pad(x, pad)
 
         x = torch.randn(2, 2, 4, 4)
-        self.run_test(Pad(), (x, pad))
+        y = pad = [2, 4]
+        self.run_test(Pad(), (x, y))
+
+        y = pad = [
+            torch.tensor(2, dtype=torch.int64),
+            torch.tensor(4, dtype=torch.int64),
+        ]
+        self.run_test(Pad(), (x, y))
 
     @skipIfUnsupportedMaxOpsetVersion(10)
     @skipScriptTest()  # TODO: the logic in symbolic_opset9 doesn't handle script

torch/onnx/_patch_torch.py

@@ -10,17 +10,15 @@
 # Import utils to get _params_dict because it is a global that is accessed by c++ code
 from torch.onnx import _deprecation, utils
 from torch.onnx._globals import GLOBALS
-from torch.onnx._internal import _beartype
 
 _ATTR_PATTERN = re.compile("^(.+)_(([ifstgz])|(ty))$")
 
 
 # TODO(#78694): Refactor the patching process to make it more transparent to users.
-@_beartype.beartype
 def _graph_op(
     g: _C.Graph,
     opname: str,
-    *raw_args: Union[torch.Tensor, torch._C.Value],
+    *raw_args: _C.Value,
     outputs: int = 1,
     **kwargs,
 ) -> Union[_C.Value, Tuple[_C.Value, ...]]:
@@ -78,7 +76,6 @@ def _graph_op(
     return tuple(n.outputs())
 
 
-@_beartype.beartype
 def _const_if_tensor(g: _C.Graph, arg):
     if arg is None:
         return arg
@@ -88,7 +85,6 @@ def _const_if_tensor(g: _C.Graph, arg):
 
 
 # Generate an ONNX ATen op node.
-@_beartype.beartype
 def _aten_op(g: _C.Graph, operator: str, *args, overload_name: str = "", **kwargs):
     return _graph_op(
         g,
@@ -100,7 +96,6 @@ def _aten_op(g: _C.Graph, operator: str, *args, overload_name: str = "", **kwarg
     )
 
 
-@_beartype.beartype
 def _block_op(b: _C.Block, opname: str, *args, **kwargs):
     if "::" in opname:
         aten = False
@@ -120,7 +115,6 @@ def _block_op(b: _C.Block, opname: str, *args, **kwargs):
     return outputs
 
 
-@_beartype.beartype
 def _new_node(
     g: _C.Graph, namespace: str, op: str, outputs: int, *args, **kwargs
 ) -> _C.Node:
@@ -144,7 +138,6 @@ def _new_node(
     return node
 
 
-@_beartype.beartype
 def _is_onnx_list(value):
     return (
         not isinstance(value, torch._six.string_classes)
@@ -153,22 +146,19 @@ def _is_onnx_list(value):
     )
 
 
-@_beartype.beartype
 def _scalar(x: torch.Tensor):
     """Convert a scalar tensor into a Python value."""
     assert x.numel() == 1
     return x[0]
 
 
-@_beartype.beartype
 def _is_caffe2_aten_fallback():
     return (
         GLOBALS.operator_export_type == _C_onnx.OperatorExportTypes.ONNX_ATEN_FALLBACK
         and _C_onnx._CAFFE2_ATEN_FALLBACK
     )
 
 
-@_beartype.beartype
 def _add_attribute(node: _C.Node, key: str, value: Any, aten: bool):
     r"""Initializes the right attribute based on type of value."""
     m = _ATTR_PATTERN.match(key)
@@ -198,7 +188,6 @@ def _add_attribute(node: _C.Node, key: str, value: Any, aten: bool):
 @_deprecation.deprecated(
     "1.13", "1.14", "Use 'g.op()' to create a constant node instead."
 )
-@_beartype.beartype
 def _graph_constant(
     g,
     value,

torch/onnx/_type_utils.py

@@ -8,7 +8,6 @@
 
 import torch
 from torch._C import _onnx as _C_onnx
-from torch.onnx._internal import _beartype
 
 ScalarName = Literal[
     "Byte",
@@ -81,7 +80,6 @@ class JitScalarType(enum.IntEnum):
     UNDEFINED = enum.auto()  # 16
 
     @classmethod
-    @_beartype.beartype
     def from_name(
         cls, name: Union[ScalarName, TorchName, Optional[str]]
     ) -> JitScalarType:
@@ -106,36 +104,30 @@ def from_name(
         raise ValueError(f"Unknown torch or scalar type: '{name}'")
 
     @classmethod
-    @_beartype.beartype
     def from_dtype(cls, dtype: torch.dtype) -> JitScalarType:
         """Convert a torch dtype to ScalarType."""
         if dtype not in _DTYPE_TO_SCALAR_TYPE:
             raise ValueError(f"Unknown dtype: {dtype}")
         return _DTYPE_TO_SCALAR_TYPE[dtype]
 
-    @_beartype.beartype
     def scalar_name(self) -> ScalarName:
         """Convert a ScalarType to a JIT scalar type name."""
         return _SCALAR_TYPE_TO_NAME[self]
 
-    @_beartype.beartype
     def torch_name(self) -> TorchName:
         """Convert a ScalarType to a torch type name."""
         return _SCALAR_TYPE_TO_TORCH_NAME[self]
 
-    @_beartype.beartype
     def dtype(self) -> torch.dtype:
         """Convert a ScalarType to a torch dtype."""
         return _SCALAR_TYPE_TO_DTYPE[self]
 
-    @_beartype.beartype
     def onnx_type(self) -> _C_onnx.TensorProtoDataType:
         """Convert a ScalarType to an ONNX data type."""
         if self not in _SCALAR_TYPE_TO_ONNX:
             raise ValueError(f"Scalar type {self} cannot be converted to ONNX")
         return _SCALAR_TYPE_TO_ONNX[self]
 
-    @_beartype.beartype
     def onnx_compatible(self) -> bool:
         """Return whether this ScalarType is compatible with ONNX."""
         return (
@@ -145,13 +137,11 @@ def onnx_compatible(self) -> bool:
         )
 
 
-@_beartype.beartype
 def valid_scalar_name(scalar_name: Union[ScalarName, str]) -> bool:
     """Return whether the given scalar name is a valid JIT scalar type name."""
     return scalar_name in _SCALAR_NAME_TO_TYPE
 
 
-@_beartype.beartype
 def valid_torch_name(torch_name: Union[TorchName, str]) -> bool:
     """Return whether the given torch name is a valid torch type name."""
     return torch_name in _TORCH_NAME_TO_SCALAR_TYPE