onnx 1.17.0__cp310-cp310-win32.whl → 1.19.0__cp310-cp310-win32.whl

onnx/backend/test/runner/__init__.py

@@ -14,7 +14,8 @@ import tempfile
 import time
 import unittest
 from collections import defaultdict
-from typing import Any, Callable, Iterable, Pattern, Sequence
+from re import Pattern
+from typing import TYPE_CHECKING, Any, Callable
 from urllib.request import urlretrieve
 
 import numpy as np
@@ -22,11 +23,15 @@ import numpy as np
 import onnx
 import onnx.reference
 from onnx import ONNX_ML, ModelProto, NodeProto, TypeProto, ValueInfoProto, numpy_helper
-from onnx.backend.base import Backend
-from onnx.backend.test.case.test_case import TestCase
 from onnx.backend.test.loader import load_model_tests
 from onnx.backend.test.runner.item import TestItem
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+
+    from onnx.backend.base import Backend
+    from onnx.backend.test.case.test_case import TestCase
+
 
 class BackendIsNotSupposedToImplementIt(unittest.SkipTest):
     pass
@@ -106,7 +111,7 @@ class Runner:
         return self
 
     def enable_report(self) -> Runner:
-        import pytest
+        import pytest  # noqa: PLC0415
 
         for category, items_map in self._test_items.items():
             for item in items_map.values():
@@ -209,14 +214,16 @@ class Runner:
                         model_dir=model_dir,
                     )
             else:
-                if not np.issubdtype(ref_outputs[i].dtype, np.number):
-                    if ref_outputs[i].tolist() != outputs[i].tolist():
-                        raise AssertionError(f"{ref_outputs[i]} != {outputs[i]}")
-                    continue
-                np.testing.assert_equal(outputs[i].dtype, ref_outputs[i].dtype)
-                if ref_outputs[i].dtype == object:  # type: ignore[attr-defined]
+                np.testing.assert_array_equal(
+                    outputs[i].shape,
+                    ref_outputs[i].shape,
+                    err_msg=f"Output {i} has incorrect shape",
+                )
+                if ref_outputs[i].dtype == object:
+                    # Strings
                     np.testing.assert_array_equal(outputs[i], ref_outputs[i])
                 else:
+                    np.testing.assert_equal(outputs[i].dtype, ref_outputs[i].dtype)
                     np.testing.assert_allclose(
                         outputs[i], ref_outputs[i], rtol=rtol, atol=atol
                     )
@@ -226,27 +233,21 @@ class Runner:
     def download_model(
         cls,
         model_test: TestCase,
-        model_dir: str,
         models_dir: str,
     ) -> None:
-        # On Windows, NamedTemporaryFile can not be opened for a
-        # second time
-        del model_dir
-        download_file = tempfile.NamedTemporaryFile(delete=False)
-        try:
-            download_file.close()
-            assert model_test.url
-            print(
-                f"Start downloading model {model_test.model_name} from {model_test.url}"
-            )
-            urlretrieve(model_test.url, download_file.name)
-            print("Done")
-            onnx.utils._extract_model_safe(download_file.name, models_dir)
-        except Exception as e:
-            print(f"Failed to prepare data for model {model_test.model_name}: {e}")
-            raise
-        finally:
-            os.remove(download_file.name)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            try:
+                assert model_test.url
+                print(
+                    f"Start downloading model {model_test.model_name} from {model_test.url}"
+                )
+                filename = os.path.join(tmpdir, "file")
+                urlretrieve(model_test.url, filename)
+                print("Done")
+                onnx.utils._extract_model_safe(filename, models_dir)
+            except Exception as e:
+                print(f"Failed to prepare data for model {model_test.model_name}: {e}")
+                raise
 
     @classmethod
     def prepare_model_data(cls, model_test: TestCase) -> str:
@@ -267,9 +268,7 @@ class Runner:
                     break
             os.makedirs(model_dir)
 
-            cls.download_model(
-                model_test=model_test, model_dir=model_dir, models_dir=models_dir
-            )
+            cls.download_model(model_test=model_test, models_dir=models_dir)
         return model_dir
 
     def _add_test(
@@ -292,7 +291,7 @@ class Runner:
                     f'Duplicated test name "{device_test_name}" in category "{category}"'
                 )
 
-            @unittest.skipIf(  # type: ignore
+            @unittest.skipIf(
                 not self.backend.supports_device(device),
                 f"Backend doesn't support device {device}",
             )

onnx/backend/test/runner/item.py

@@ -4,9 +4,10 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any, Callable
 
-from onnx import ModelProto, NodeProto
+if TYPE_CHECKING:
+    from onnx import ModelProto, NodeProto
 
 # A container that hosts the test function and the associated
 # test item (ModelProto)

onnx/backend/test/stat_coverage.py

@@ -6,13 +6,16 @@
 from __future__ import annotations
 
 import os
-from typing import IO, Any, Sequence
+from typing import IO, TYPE_CHECKING, Any
 
 from onnx import AttributeProto, defs, load
 from onnx.backend.test.case import collect_snippets
 from onnx.backend.test.loader import load_model_tests
 from onnx.backend.test.runner import Runner
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 def is_ml(schemas: Sequence[defs.OpSchema]) -> bool:
     return any(s.domain == "ai.onnx.ml" for s in schemas)
@@ -252,7 +255,7 @@ def gen_model_test_coverage(
 
 
 def gen_overall_test_coverage(
-    schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool  # noqa: ARG001
+    f: IO[Any],
 ) -> None:
     f.write("# Overall Test Coverage\n")
     f.write("## To be filled.\n")
@@ -276,7 +279,7 @@ def main() -> None:
         gen_outlines(f, False)
         gen_node_test_coverage(schemas, f, False)
         gen_model_test_coverage(schemas, f, False)
-        gen_overall_test_coverage(schemas, f, False)
+        gen_overall_test_coverage(f)
 
     if has_ml:
         fname = os.path.join(docs_dir, "TestCoverage-ml.md")
@@ -285,7 +288,7 @@ def main() -> None:
             gen_outlines(f, True)
             gen_node_test_coverage(schemas, f, True)
             gen_model_test_coverage(schemas, f, True)
-            gen_overall_test_coverage(schemas, f, True)
+            gen_overall_test_coverage(f)
 
 
 if __name__ == "__main__":

onnx/checker.cc

@@ -4,10 +4,7 @@
 
 #include "onnx/checker.h"
 
-#include <fstream>
-#include <functional>
-#include <iterator>
-#include <set>
+#include <filesystem>
 #include <string>
 #include <unordered_set>
 #include <vector>
@@ -15,17 +12,11 @@
 #include "onnx/common/file_utils.h"
 #include "onnx/defs/schema.h"
 #include "onnx/defs/tensor_proto_util.h"
-#include "onnx/proto_utils.h"
 #include "onnx/shape_inference/implementation.h"
 #include "onnx/string_utils.h"
 
 #ifdef _WIN32
-#include <direct.h>
-
-#include <filesystem>
-
-#else // POSIX
-#include <sys/stat.h>
+#include "onnx/common/path.h"
 #endif
 
 namespace ONNX_NAMESPACE {
@@ -96,11 +87,11 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
 
   const char* value_field = nullptr;
 
-#define check_data_field(field)             \
-  bool has_##field = tensor.field().size(); \
-  if (has_##field) {                        \
-    ++num_value_fields;                     \
-    value_field = #field;                   \
+#define check_data_field(field)               \
+  bool has_##field = !tensor.field().empty(); \
+  if (has_##field) {                          \
+    ++num_value_fields;                       \
+    value_field = #field;                     \
   }
 
   check_data_field(float_data);
@@ -186,8 +177,10 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
       case TensorProto::FLOAT8E4M3FNUZ:
       case TensorProto::FLOAT8E5M2:
       case TensorProto::FLOAT8E5M2FNUZ:
+      case TensorProto::FLOAT8E8M0:
       case TensorProto::UINT4:
       case TensorProto::INT4:
+      case TensorProto::FLOAT4E2M1:
         check_field(int32_data);
         break;
 
@@ -313,10 +306,8 @@ void check_map(const MapProto& map, const CheckerContext& ctx) {
 // Check that the index data stored in a SparseTensorProto is valid.
 // indices: a 1-dimensional tensor; indices[i] represents the
 // linearized index value for the i-th nonzero value.
-void check_sparse_tensor_indices_1(
-    const TensorProto& indices,
-    const SparseTensorProto& sparse_tensor_proto,
-    size_t nnz) {
+static void
+check_sparse_tensor_indices_1(const TensorProto& indices, const SparseTensorProto& sparse_tensor_proto, size_t nnz) {
   int dense_rank = sparse_tensor_proto.dims_size();
   int64_t dense_size = 1;
   for (int i = 0; i < dense_rank; ++i)
@@ -353,10 +344,8 @@ void check_sparse_tensor_indices_1(
 // Check that the index data stored in a SparseTensorProto is valid.
 // indices: a 2-dimensional tensor; indices[i,j] represents the j-th
 // index value for the i-th nonzero value.
-void check_sparse_tensor_indices_2(
-    const TensorProto& indices,
-    const SparseTensorProto& sparse_tensor_proto,
-    size_t nnz) {
+static void
+check_sparse_tensor_indices_2(const TensorProto& indices, const SparseTensorProto& sparse_tensor_proto, size_t nnz) {
   int dense_rank = sparse_tensor_proto.dims_size();
   if (static_cast<size_t>(indices.dims(0)) != nnz) {
     fail_check("Sparse tensor indices (", indices.name(), ") first dimension size does not equal NNZ.");
@@ -517,7 +506,7 @@ void check_attribute(const AttributeProto& attr, const CheckerContext& ctx, cons
   for (const auto& sparse_tensor : attr.sparse_tensors()) {
     check_sparse_tensor(sparse_tensor, ctx);
   }
-  if (attr.graphs().size() > 0) {
+  if (!attr.graphs().empty()) {
     CheckerContext subgraph_ctx(ctx);
     subgraph_ctx.set_is_main_graph(false);
     for (const auto& graph : attr.graphs()) {
@@ -526,7 +515,7 @@ void check_attribute(const AttributeProto& attr, const CheckerContext& ctx, cons
   }
 }
 
-void print_warning_if_has_experimental(const std::unordered_set<std::string>& used_experimental_ops) {
+static void print_warning_if_has_experimental(const std::unordered_set<std::string>& used_experimental_ops) {
   if (!used_experimental_ops.empty()) {
     std::string all_experimental_ops;
     for (const auto& op : used_experimental_ops) {
@@ -534,7 +523,7 @@ void print_warning_if_has_experimental(const std::unordered_set<std::string>& us
     }
     // Remove the last comma which is unnecessary
     all_experimental_ops.pop_back();
-    std::cout << "Warning: Model contains experimental ops:" + all_experimental_ops << std::endl;
+    std::cout << "Warning: Model contains experimental ops:" + all_experimental_ops << '\n';
   }
 }
 
@@ -614,8 +603,7 @@ void check_graph(const GraphProto& graph, const CheckerContext& ctx, const Lexic
     lex_ctx.add(value_info.name());
   }
 
-  std::unordered_set<std::reference_wrapper<const std::string>, std::hash<std::string>, std::equal_to<std::string>>
-      initializer_name_checker;
+  std::unordered_set<std::string> initializer_name_checker;
 
   for (const auto& init : graph.initializer()) {
     enforce_has_field(init, name);
@@ -624,7 +612,7 @@ void check_graph(const GraphProto& graph, const CheckerContext& ctx, const Lexic
       fail_check("Tensor initializers must have a non-empty name");
     }
 
-    if (!initializer_name_checker.insert(std::cref(name)).second) {
+    if (!initializer_name_checker.emplace(name).second) {
       fail_check(name + " initializer name is not unique");
     }
 
@@ -649,7 +637,7 @@ void check_graph(const GraphProto& graph, const CheckerContext& ctx, const Lexic
     if (name.empty()) {
       fail_check("Sparse tensor initializers must have a non-empty name");
     }
-    if (!initializer_name_checker.insert(std::cref(name)).second) {
+    if (!initializer_name_checker.insert(name).second) {
       fail_check(name + " sparse initializer name is not unique across initializers and sparse_initializers");
     }
     check_sparse_tensor(sparse_init, ctx);
@@ -720,7 +708,9 @@ void check_graph(const GraphProto& graph, const CheckerContext& ctx, const Lexic
 
 // Utilify function to get the imported version of domain from opset imports
 // Returns -1 if requested domain is not found in the opset_imports
-int get_version_for_domain(const std::string& domain, const std::unordered_map<std::string, int>& opset_imports) {
+static int get_version_for_domain(
+    const std::string& domain,
+    const std::unordered_map<std::string, int>& opset_imports) {
   auto it = opset_imports.find(domain);
   if (it == opset_imports.end()) {
     return -1;
@@ -894,7 +884,7 @@ void check_function(const FunctionProto& function, const CheckerContext& ctx, co
   print_warning_if_has_experimental(used_experimental_ops);
 }
 
-void check_model(const ModelProto& model, CheckerContext& ctx) {
+static void check_model(const ModelProto& model, CheckerContext& ctx) {
   if (!model.ir_version()) {
     fail_check("The model does not have an ir_version set properly.");
   }
@@ -984,50 +974,29 @@ std::string resolve_external_data_location(
     const std::string& location,
     const std::string& tensor_name) {
 #ifdef _WIN32
-  auto file_path = std::filesystem::path(utf8str_to_wstring(location));
-  if (file_path.is_absolute()) {
-    fail_check(
-        "Location of external TensorProto ( tensor name: ",
-        tensor_name,
-        ") should be a relative path, but it is an absolute path: ",
-        location);
-  }
-  auto relative_path = file_path.lexically_normal().make_preferred().wstring();
-  // Check that normalized relative path contains ".." on Windows.
-  if (relative_path.find(L"..", 0) != std::string::npos) {
-    fail_check(
-        "Data of TensorProto ( tensor name: ",
-        tensor_name,
-        ") should be file inside the ",
-        base_dir,
-        ", but the '",
-        location,
-        "' points outside the directory");
-  }
-  std::wstring data_path = path_join(utf8str_to_wstring(base_dir), relative_path);
-  struct _stat64 buff;
-  if (data_path.empty() || (data_path[0] != '#' && _wstat64(data_path.c_str(), &buff) != 0)) {
-    fail_check(
-        "Data of TensorProto ( tensor name: ",
-        tensor_name,
-        ") should be stored in ",
-        location,
-        ", but it doesn't exist or is not accessible.");
-  }
-  return wstring_to_utf8str(data_path);
+  std::filesystem::path base_dir_path(utf8str_to_wstring(base_dir));
+  std::filesystem::path file_path(utf8str_to_wstring(location));
 #else // POSIX
-  if (location.empty()) {
+  std::filesystem::path base_dir_path(base_dir);
+  std::filesystem::path file_path(location);
+#endif
+  if (file_path.empty()) {
     fail_check("Location of external TensorProto ( tensor name: ", tensor_name, ") should not be empty.");
-  } else if (location[0] == '/') {
+  }
+  if (file_path.is_absolute()) {
     fail_check(
         "Location of external TensorProto ( tensor name: ",
         tensor_name,
         ") should be a relative path, but it is an absolute path: ",
         location);
   }
-  std::string relative_path = clean_relative_path(location);
-  // Check that normalized relative path contains ".." on POSIX
-  if (relative_path.find("..", 0) != std::string::npos) {
+  auto relative_path = file_path.lexically_normal().make_preferred();
+  // Check that normalized relative path doesn't contains ".."
+#ifdef _WIN32
+  if (relative_path.native().find(L"..", 0) != std::string::npos) {
+#else // POSIX
+  if (relative_path.native().find("..", 0) != std::string::npos) {
+#endif
     fail_check(
         "Data of TensorProto ( tensor name: ",
         tensor_name,
@@ -1037,36 +1006,34 @@ std::string resolve_external_data_location(
         location,
         "' points outside the directory");
   }
-  std::string data_path = path_join(base_dir, relative_path);
-  // use stat64 to check whether the file exists
-#if defined(__APPLE__) || defined(__wasm__) || !defined(__GLIBC__)
-  struct stat buffer; // APPLE, wasm and non-glic stdlibs do not have stat64
-  if (data_path.empty() || (data_path[0] != '#' && stat((data_path).c_str(), &buffer) != 0)) {
+  auto data_path = base_dir_path / relative_path;
+#ifdef _WIN32
+  auto data_path_str = wstring_to_utf8str(data_path.native());
 #else
-  struct stat64 buffer; // All POSIX under glibc except APPLE and wasm have stat64
-  if (data_path.empty() || (data_path[0] != '#' && stat64((data_path).c_str(), &buffer) != 0)) {
+  auto data_path_str = data_path.native();
 #endif
+  // Check whether the file exists
+  if (data_path.empty() || (data_path_str[0] != '#' && !std::filesystem::exists(data_path))) {
     fail_check(
         "Data of TensorProto ( tensor name: ",
         tensor_name,
         ") should be stored in ",
-        data_path,
+        data_path_str,
         ", but it doesn't exist or is not accessible.");
   }
   // Do not allow symlinks or directories.
-  if (data_path.empty() || (data_path[0] != '#' && !S_ISREG(buffer.st_mode))) {
+  if (data_path.empty() || (data_path_str[0] != '#' && !std::filesystem::is_regular_file(data_path))) {
     fail_check(
         "Data of TensorProto ( tensor name: ",
         tensor_name,
         ") should be stored in ",
-        data_path,
+        data_path_str,
         ", but it is not regular file.");
   }
-  return data_path;
-#endif
+  return data_path_str;
 }
 
-std::set<std::string> experimental_ops = {
+static std::unordered_set<std::string> experimental_ops = {
     "ATen",
     "Affine",
     "ConstantFill",

onnx/checker.h

@@ -10,11 +10,8 @@
 #include <unordered_set>
 #include <utility>
 
-#include "onnx/defs/function.h"
 #include "onnx/defs/schema.h"
-#include "onnx/onnx-data_pb.h"
-#include "onnx/onnx-operators_pb.h"
-#include "onnx/onnx_pb.h"
+#include "onnx/onnx-data.pb.h"
 #include "onnx/string_utils.h"
 
 namespace ONNX_NAMESPACE {
@@ -92,10 +89,10 @@ class CheckerContext final {
     check_custom_domain_ = value;
   }
 
-  explicit CheckerContext() : ir_version_(-1) {}
+  explicit CheckerContext() = default;
 
  private:
-  int ir_version_;
+  int ir_version_{-1};
   std::unordered_map<std::string, int> opset_imports_;
   bool is_main_graph_ = true;
   const ISchemaRegistry* schema_registry_ = OpSchemaRegistry::Instance();
@@ -107,6 +104,7 @@ class CheckerContext final {
 class LexicalScopeContext final {
  public:
   LexicalScopeContext() = default;
+  ~LexicalScopeContext() = default;
 
   // Construct an instance with the lexical scope from the parent graph to allow
   // lookup of names from that scope via this_or_ancestor_graph_has.
@@ -116,16 +114,21 @@ class LexicalScopeContext final {
   // values from the parent scope so the values are copied instead.
   LexicalScopeContext(const LexicalScopeContext& parent_context) : parent_context_{&parent_context} {}
   LexicalScopeContext& operator=(const LexicalScopeContext& parent_context) {
+    if (this == &parent_context) {
+      return *this;
+    }
     parent_context_ = &parent_context;
     return *this;
   }
+  LexicalScopeContext(LexicalScopeContext&&) = delete;
+  LexicalScopeContext& operator=(LexicalScopeContext&&) = delete;
 
   void add(const std::string& name) {
     output_names.insert(name);
   }
 
   bool this_graph_has(const std::string& name) const {
-    return output_names.find(name) != output_names.cend();
+    return output_names.count(name) > 0;
   }
 
   bool this_or_ancestor_graph_has(const std::string& name) const {

onnx/checker.py

@@ -23,31 +23,17 @@ __all__ = [
 
 import os
 import sys
-from typing import Any, Callable, TypeVar
-
-from google.protobuf.message import Message
+from typing import TYPE_CHECKING
 
 import onnx.defs
 import onnx.onnx_cpp2py_export.checker as C  # noqa: N812
-import onnx.shape_inference
-from onnx import (
-    IR_VERSION,
-    AttributeProto,
-    FunctionProto,
-    GraphProto,
-    ModelProto,
-    NodeProto,
-    SparseTensorProto,
-    TensorProto,
-    ValueInfoProto,
-)
-
-# Limitation of single protobuf file is 2GB
-MAXIMUM_PROTOBUF = 2000000000
-
-# TODO: This thing where we reserialize the protobuf back into the
-# string, only to deserialize it at the call site, is really goofy.
-# Stop doing that.
+from onnx.onnx_pb import IR_VERSION
+
+if TYPE_CHECKING:
+    from google.protobuf.message import Message
+
+# Limitation of single protobuf file is 2GiB
+MAXIMUM_PROTOBUF = 2147483648
 
 
 # NB: Please don't edit this context!
@@ -59,9 +45,6 @@ DEFAULT_CONTEXT.opset_imports = {"": onnx.defs.onnx_opset_version()}
 LEXICAL_SCOPE_CONTEXT = C.LexicalScopeContext()
 
 
-FuncType = TypeVar("FuncType", bound=Callable[..., Any])
-
-
 def _ensure_proto_type(proto: Message, proto_type: type[Message]) -> None:
     if not isinstance(proto, proto_type):
         raise TypeError(
@@ -70,41 +53,43 @@ def _ensure_proto_type(proto: Message, proto_type: type[Message]) -> None:
 
 
 def check_value_info(
-    value_info: ValueInfoProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
+    value_info: onnx.ValueInfoProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
 ) -> None:
-    _ensure_proto_type(value_info, ValueInfoProto)
+    _ensure_proto_type(value_info, onnx.ValueInfoProto)
     return C.check_value_info(value_info.SerializeToString(), ctx)
 
 
-def check_tensor(tensor: TensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> None:
-    _ensure_proto_type(tensor, TensorProto)
+def check_tensor(
+    tensor: onnx.TensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
+) -> None:
+    _ensure_proto_type(tensor, onnx.TensorProto)
     return C.check_tensor(tensor.SerializeToString(), ctx)
 
 
 def check_attribute(
-    attr: AttributeProto,
+    attr: onnx.AttributeProto,
     ctx: C.CheckerContext = DEFAULT_CONTEXT,
     lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
 ) -> None:
-    _ensure_proto_type(attr, AttributeProto)
+    _ensure_proto_type(attr, onnx.AttributeProto)
     return C.check_attribute(attr.SerializeToString(), ctx, lexical_scope_ctx)
 
 
 def check_node(
-    node: NodeProto,
+    node: onnx.NodeProto,
     ctx: C.CheckerContext = DEFAULT_CONTEXT,
     lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
 ) -> None:
-    _ensure_proto_type(node, NodeProto)
+    _ensure_proto_type(node, onnx.NodeProto)
     return C.check_node(node.SerializeToString(), ctx, lexical_scope_ctx)
 
 
 def check_function(
-    function: FunctionProto,
+    function: onnx.FunctionProto,
     ctx: C.CheckerContext | None = None,
     lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
 ) -> None:
-    _ensure_proto_type(function, FunctionProto)
+    _ensure_proto_type(function, onnx.FunctionProto)
     if ctx is None:
         ctx = C.CheckerContext()
         ctx.ir_version = onnx.helper.find_min_ir_version_for(
@@ -118,23 +103,23 @@ def check_function(
 
 
 def check_graph(
-    graph: GraphProto,
+    graph: onnx.GraphProto,
     ctx: C.CheckerContext = DEFAULT_CONTEXT,
     lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
 ) -> None:
-    _ensure_proto_type(graph, GraphProto)
+    _ensure_proto_type(graph, onnx.GraphProto)
     return C.check_graph(graph.SerializeToString(), ctx, lexical_scope_ctx)
 
 
 def check_sparse_tensor(
-    sparse: SparseTensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
+    sparse: onnx.SparseTensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
 ) -> None:
-    _ensure_proto_type(sparse, SparseTensorProto)
+    _ensure_proto_type(sparse, onnx.SparseTensorProto)
     C.check_sparse_tensor(sparse.SerializeToString(), ctx)
 
 
 def check_model(
-    model: ModelProto | str | bytes | os.PathLike,
+    model: onnx.ModelProto | str | bytes | os.PathLike,
     full_check: bool = False,
     skip_opset_compatibility_check: bool = False,
     check_custom_domain: bool = False,
@@ -170,11 +155,11 @@ def check_model(
         protobuf_string = (
             model if isinstance(model, bytes) else model.SerializeToString()
         )
-        # If the protobuf is larger than 2GB,
+        # If the protobuf is larger than 2GiB,
         # remind users should use the model path to check
         if sys.getsizeof(protobuf_string) > MAXIMUM_PROTOBUF:
             raise ValueError(
-                "This protobuf of onnx model is too large (>2GB). Call check_model with model path instead."
+                "This protobuf of onnx model is too large (>2GiB). Call check_model with model path instead."
             )
         C.check_model(
             protobuf_string,