onnx 1.15.0__cp310-cp310-win_amd64.whl → 1.16.1__cp310-cp310-win_amd64.whl

onnx/backend/test/runner/__init__.py

@@ -137,8 +137,7 @@ class Runner:
 
     @property
     def test_cases(self) -> dict[str, type[unittest.TestCase]]:
-        """
-        List of test cases to be applied on the parent scope
+        """List of test cases to be applied on the parent scope
         Example usage:
             globals().update(BackendTest(backend).test_cases)
         """
@@ -153,8 +152,7 @@ class Runner:
 
     @property
     def test_suite(self) -> unittest.TestSuite:
-        """
-        TestSuite that can be run by TestRunner
+        """TestSuite that can be run by TestRunner
         Example usage:
             unittest.TextTestRunner().run(BackendTest(backend).test_suite)
         """
@@ -168,8 +166,7 @@ class Runner:
     # For backward compatibility (we used to expose `.tests`)
     @property
     def tests(self) -> type[unittest.TestCase]:
-        """
-        One single unittest.TestCase that hosts all the test functions
+        """One single unittest.TestCase that hosts all the test functions
         Example usage:
             onnx_backend_tests = BackendTest(backend).tests
         """
@@ -188,15 +185,35 @@ class Runner:
         outputs: Sequence[Any],
         rtol: float,
         atol: float,
+        model_dir: str | None = None,
     ) -> None:
-        np.testing.assert_equal(len(outputs), len(ref_outputs))
+        try:
+            np.testing.assert_equal(len(outputs), len(ref_outputs))
+        except TypeError as e:
+            raise TypeError(
+                f"Unable to compare expected type {type(ref_outputs)} "
+                f"and runtime type {type(outputs)} (known test={model_dir or '?'!r})"
+            ) from e
         for i in range(len(outputs)):
             if isinstance(outputs[i], (list, tuple)):
+                if not isinstance(ref_outputs[i], (list, tuple)):
+                    raise AssertionError(
+                        f"Unexpected type {type(outputs[i])} for outputs[{i}]. Expected "
+                        f"type is {type(ref_outputs[i])} (known test={model_dir or '?'!r})."
+                    )
                 for j in range(len(outputs[i])):
                     cls.assert_similar_outputs(
-                        ref_outputs[i][j], outputs[i][j], rtol, atol
+                        ref_outputs[i][j],
+                        outputs[i][j],
+                        rtol,
+                        atol,
+                        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], ref_outputs[i])
@@ -298,9 +315,7 @@ class Runner:
     def generate_dummy_data(
         x: ValueInfoProto, seed: int = 0, name: str = "", random: bool = False
     ) -> np.ndarray:
-        """
-        Generates a random tensor based on the input definition.
-        """
+        """Generates a random tensor based on the input definition."""
         if not x.type.tensor_type:
             raise NotImplementedError(
                 f"Input expected to have tensor type. "
@@ -437,9 +452,16 @@ class Runner:
                     test_data = np.load(test_data_npz, encoding="bytes")
                     inputs = list(test_data["inputs"])
                     outputs = list(prepared_model.run(inputs))
-                    ref_outputs = test_data["outputs"]
+                    ref_outputs = tuple(
+                        np.array(x) if not isinstance(x, (list, dict)) else x
+                        for f in test_data["outputs"]
+                    )
                     self.assert_similar_outputs(
-                        ref_outputs, outputs, rtol=model_test.rtol, atol=model_test.atol
+                        ref_outputs,
+                        outputs,
+                        rtol=model_test.rtol,
+                        atol=model_test.atol,
+                        model_dir=model_dir,
                     )
 
             for test_data_dir in glob.glob(os.path.join(model_dir, "test_data_set*")):
@@ -459,7 +481,11 @@ class Runner:
                     )
                 outputs = list(prepared_model.run(inputs))
                 self.assert_similar_outputs(
-                    ref_outputs, outputs, rtol=model_test.rtol, atol=model_test.atol
+                    ref_outputs,
+                    outputs,
+                    rtol=model_test.rtol,
+                    atol=model_test.atol,
+                    model_dir=model_dir,
                 )
 
         if model_test.name in self._test_kwargs:
@@ -488,7 +514,9 @@ class Runner:
             elif model_type_proto.HasField("tensor_type"):
                 tensor = onnx.TensorProto()
                 tensor.ParseFromString(protobuf_content)
-                target_list.append(numpy_helper.to_array(tensor))
+                t = numpy_helper.to_array(tensor)
+                assert isinstance(t, np.ndarray)
+                target_list.append(t)
             elif model_type_proto.HasField("optional_type"):
                 optional = onnx.OptionalProto()
                 optional.ParseFromString(protobuf_content)

onnx/checker.cc

@@ -13,7 +13,6 @@
 #include <vector>
 
 #include "onnx/common/file_utils.h"
-#include "onnx/common/path.h"
 #include "onnx/defs/schema.h"
 #include "onnx/defs/tensor_proto_util.h"
 #include "onnx/proto_utils.h"
@@ -39,13 +38,6 @@ namespace checker {
     }                                                                                \
   } while (0)
 
-#define enforce_has_repeated_field(proto, field)                                              \
-  do {                                                                                        \
-    if (!proto.field##_size()) {                                                              \
-      fail_check("Repeated Field '", #field, "' of '", #proto, "' is required but missing."); \
-    }                                                                                         \
-  } while (0)
-
 #define enforce_non_empty_field(proto, field)                                            \
   do {                                                                                   \
     if (proto.field().empty()) {                                                         \
@@ -135,85 +127,7 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
     for (const StringStringEntryProto& entry : tensor.external_data()) {
       if (entry.has_key() && entry.has_value() && entry.key() == "location") {
         has_location = true;
-#ifdef _WIN32
-        auto file_path = std::filesystem::path(utf8str_to_wstring(entry.value()));
-        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: ",
-              entry.value());
-        }
-        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 ",
-              ctx.get_model_dir(),
-              ", but the '",
-              entry.value(),
-              "' points outside the directory");
-        }
-        std::wstring data_path = path_join(utf8str_to_wstring(ctx.get_model_dir()), relative_path);
-        struct _stat64 buff;
-        if (_wstat64(data_path.c_str(), &buff) != 0) {
-          fail_check(
-              "Data of TensorProto ( tensor name: ",
-              tensor.name(),
-              ") should be stored in ",
-              entry.value(),
-              ", but it doesn't exist or is not accessible.");
-        }
-#else // POSIX
-        if (entry.value().empty()) {
-          fail_check("Location of external TensorProto ( tensor name: ", tensor.name(), ") should not be empty.");
-        } else if (entry.value()[0] == '/') {
-          fail_check(
-              "Location of external TensorProto ( tensor name: ",
-              tensor.name(),
-              ") should be a relative path, but it is an absolute path: ",
-              entry.value());
-        }
-        std::string relative_path = clean_relative_path(entry.value());
-        // Check that normalized relative path contains ".." on POSIX
-        if (relative_path.find("..", 0) != std::string::npos) {
-          fail_check(
-              "Data of TensorProto ( tensor name: ",
-              tensor.name(),
-              ") should be file inside the ",
-              ctx.get_model_dir(),
-              ", but the '",
-              entry.value(),
-              "' points outside the directory");
-        }
-        std::string data_path = path_join(ctx.get_model_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 (stat((data_path).c_str(), &buffer) != 0) {
-#else
-        struct stat64 buffer; // All POSIX under glibc except APPLE and wasm have stat64
-        if (stat64((data_path).c_str(), &buffer) != 0) {
-#endif
-          fail_check(
-              "Data of TensorProto ( tensor name: ",
-              tensor.name(),
-              ") should be stored in ",
-              data_path,
-              ", but it doesn't exist or is not accessible.");
-        }
-        // Do not allow symlinks or directories.
-        if (!S_ISREG(buffer.st_mode)) {
-          fail_check(
-              "Data of TensorProto ( tensor name: ",
-              tensor.name(),
-              ") should be stored in ",
-              data_path,
-              ", but it is not regular file.");
-        }
-#endif
+        resolve_external_data_location(ctx.get_model_dir(), entry.value(), tensor.name());
       }
     }
     if (!has_location) {
@@ -272,6 +186,8 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
       case TensorProto::FLOAT8E4M3FNUZ:
       case TensorProto::FLOAT8E5M2:
       case TensorProto::FLOAT8E5M2FNUZ:
+      case TensorProto::UINT4:
+      case TensorProto::INT4:
         check_field(int32_data);
         break;
 
@@ -656,17 +572,11 @@ void check_node(const NodeProto& node, const CheckerContext& ctx, const LexicalS
   const auto* schema = ctx.get_schema_registry()->GetSchema(node.op_type(), domain_version, node.domain());
   if (!schema) {
     if (node.domain() == ONNX_DOMAIN || node.domain() == AI_ONNX_ML_DOMAIN || node.domain() == "ai.onnx" ||
-        node.domain() == AI_ONNX_TRAINING_DOMAIN) {
-      // fail the checker if op in built-in domains has no schema
+        node.domain() == AI_ONNX_TRAINING_DOMAIN || ctx.check_custom_domain()) {
+      // fail the checker if op is in built-in domains or if it has no schema when `check_custom_domain` is true
       fail_check(
           "No Op registered for " + node.op_type() + " with domain_version of " +
           ONNX_NAMESPACE::to_string(domain_version));
-    } else {
-      // TODO: expose the registration of the op schemas appropriately in
-      // python, so we can load and register operators in other domains
-      //
-      // before we complete the above todo, let's skip the schema check for
-      // now
     }
   } else if (schema->Deprecated()) {
     fail_check(
@@ -1021,7 +931,11 @@ void check_model(const ModelProto& model, CheckerContext& ctx) {
   }
 }
 
-void check_model(const std::string& model_path, bool full_check, bool skip_opset_compatibility_check) {
+void check_model(
+    const std::string& model_path,
+    bool full_check,
+    bool skip_opset_compatibility_check,
+    bool check_custom_domain) {
   ModelProto model;
   LoadProtoFromPath(model_path, model);
 
@@ -1033,6 +947,7 @@ void check_model(const std::string& model_path, bool full_check, bool skip_opset
   }
   ctx.set_model_dir(model_dir);
   ctx.set_skip_opset_compatibility_check(skip_opset_compatibility_check);
+  ctx.set_check_custom_domain(check_custom_domain);
   check_model(model, ctx);
 
   if (full_check) {
@@ -1041,9 +956,14 @@ void check_model(const std::string& model_path, bool full_check, bool skip_opset
   }
 }
 
-void check_model(const ModelProto& model, bool full_check, bool skip_opset_compatibility_check) {
+void check_model(
+    const ModelProto& model,
+    bool full_check,
+    bool skip_opset_compatibility_check,
+    bool check_custom_domain) {
   CheckerContext ctx;
   ctx.set_skip_opset_compatibility_check(skip_opset_compatibility_check);
+  ctx.set_check_custom_domain(check_custom_domain);
   check_model(model, ctx);
   if (full_check) {
     ShapeInferenceOptions options{true, 1, false};
@@ -1054,6 +974,93 @@ void check_model(const ModelProto& model, bool full_check, bool skip_opset_compa
   }
 }
 
+std::string resolve_external_data_location(
+    const std::string& base_dir,
+    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);
+#else // POSIX
+  if (location.empty()) {
+    fail_check("Location of external TensorProto ( tensor name: ", tensor_name, ") should not be empty.");
+  } else if (location[0] == '/') {
+    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) {
+    fail_check(
+        "Data of TensorProto ( tensor name: ",
+        tensor_name,
+        ") should be file inside the ",
+        base_dir,
+        ", but the '",
+        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)) {
+#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)) {
+#endif
+    fail_check(
+        "Data of TensorProto ( tensor name: ",
+        tensor_name,
+        ") should be stored in ",
+        data_path,
+        ", 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))) {
+    fail_check(
+        "Data of TensorProto ( tensor name: ",
+        tensor_name,
+        ") should be stored in ",
+        data_path,
+        ", but it is not regular file.");
+  }
+  return data_path;
+#endif
+}
+
 std::set<std::string> experimental_ops = {
     "ATen",
     "Affine",
@@ -1071,9 +1078,7 @@ bool check_is_experimental_op(const NodeProto& node) {
   return (node.domain() == ONNX_DOMAIN || node.domain() == "ai.onnx") && experimental_ops.count(node.op_type());
 }
 
-#undef fail_check
 #undef enforce_has_field
-#undef enforce_has_repeated_field
 #undef enforce_non_empty_field
 
 } // namespace checker

onnx/checker.h

@@ -84,6 +84,14 @@ class CheckerContext final {
     skip_opset_compatibility_check_ = value;
   }
 
+  bool check_custom_domain() const {
+    return check_custom_domain_;
+  }
+
+  void set_check_custom_domain(bool value) {
+    check_custom_domain_ = value;
+  }
+
   explicit CheckerContext() : ir_version_(-1) {}
 
  private:
@@ -93,6 +101,7 @@ class CheckerContext final {
   const ISchemaRegistry* schema_registry_ = OpSchemaRegistry::Instance();
   std::string model_dir_;
   bool skip_opset_compatibility_check_ = false;
+  bool check_custom_domain_ = false;
 };
 
 class LexicalScopeContext final {
@@ -158,9 +167,20 @@ void check_model_local_functions(
     const CheckerContext& ctx,
     const LexicalScopeContext& parent_lex);
 
-void check_model(const ModelProto& model, bool full_check = false, bool skip_opset_compatibility_check = false);
-void check_model(const std::string& model_path, bool full_check = false, bool skip_opset_compatibility_check = false);
-
+void check_model(
+    const ModelProto& model,
+    bool full_check = false,
+    bool skip_opset_compatibility_check = false,
+    bool check_custom_domain = false);
+void check_model(
+    const std::string& model_path,
+    bool full_check = false,
+    bool skip_opset_compatibility_check = false,
+    bool check_custom_domain = false);
+std::string resolve_external_data_location(
+    const std::string& base_dir,
+    const std::string& location,
+    const std::string& tensor_name);
 bool check_is_experimental_op(const NodeProto& node);
 
 } // namespace checker

onnx/checker.py

@@ -15,6 +15,7 @@ __all__ = [
     "check_tensor",
     "check_value_info",
     "DEFAULT_CONTEXT",
+    "LEXICAL_SCOPE_CONTEXT",
     "ValidationError",
     "C",
     "MAXIMUM_PROTOBUF",
@@ -39,7 +40,6 @@ from onnx import (
     SparseTensorProto,
     TensorProto,
     ValueInfoProto,
-    helper,
 )
 
 # Limitation of single protobuf file is 2GB
@@ -56,6 +56,8 @@ DEFAULT_CONTEXT.ir_version = IR_VERSION
 # TODO: Maybe ONNX-ML should also be defaulted?
 DEFAULT_CONTEXT.opset_imports = {"": onnx.defs.onnx_opset_version()}
 
+LEXICAL_SCOPE_CONTEXT = C.LexicalScopeContext()
+
 
 FuncType = TypeVar("FuncType", bound=Callable[..., Any])
 
@@ -80,36 +82,48 @@ def check_tensor(tensor: TensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT) -
 
 
 def check_attribute(
-    attr: AttributeProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
+    attr: AttributeProto,
+    ctx: C.CheckerContext = DEFAULT_CONTEXT,
+    lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
 ) -> None:
     _ensure_proto_type(attr, AttributeProto)
-    return C.check_attribute(attr.SerializeToString(), ctx)
+    return C.check_attribute(attr.SerializeToString(), ctx, lexical_scope_ctx)
 
 
-def check_node(node: NodeProto, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> None:
+def check_node(
+    node: NodeProto,
+    ctx: C.CheckerContext = DEFAULT_CONTEXT,
+    lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
+) -> None:
     _ensure_proto_type(node, NodeProto)
-    return C.check_node(node.SerializeToString(), ctx)
+    return C.check_node(node.SerializeToString(), ctx, lexical_scope_ctx)
 
 
 def check_function(
-    function: FunctionProto, ctx: C.CheckerContext | None = None
+    function: FunctionProto,
+    ctx: C.CheckerContext | None = None,
+    lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
 ) -> None:
     _ensure_proto_type(function, FunctionProto)
     if ctx is None:
         ctx = C.CheckerContext()
-        ctx.ir_version = helper.find_min_ir_version_for(
-            list(function.opset_import), True
+        ctx.ir_version = onnx.helper.find_min_ir_version_for(
+            function.opset_import, ignore_unknown=True
         )
-        function_opset_dic = {}
-        for domain_version in function.opset_import:
-            function_opset_dic[domain_version.domain] = domain_version.version
-        ctx.opset_imports = function_opset_dic
-    C.check_function(function.SerializeToString(), ctx)
+        ctx.opset_imports = {
+            domain_version.domain: domain_version.version
+            for domain_version in function.opset_import
+        }
+    C.check_function(function.SerializeToString(), ctx, lexical_scope_ctx)
 
 
-def check_graph(graph: GraphProto, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> None:
+def check_graph(
+    graph: GraphProto,
+    ctx: C.CheckerContext = DEFAULT_CONTEXT,
+    lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
+) -> None:
     _ensure_proto_type(graph, GraphProto)
-    return C.check_graph(graph.SerializeToString(), ctx)
+    return C.check_graph(graph.SerializeToString(), ctx, lexical_scope_ctx)
 
 
 def check_sparse_tensor(
@@ -123,18 +137,35 @@ def check_model(
     model: ModelProto | str | bytes | os.PathLike,
     full_check: bool = False,
     skip_opset_compatibility_check: bool = False,
+    check_custom_domain: bool = False,
 ) -> None:
-    """Check the consistency of a model. An exception is raised if the test fails.
+    """Check the consistency of a model.
+
+    An exception will be raised if the model's ir_version is not set
+    properly or is higher than checker's ir_version, or if the model
+    has duplicate keys in metadata_props.
+
+    If IR version >= 3, the model must specify opset_import.
+    If IR version < 3, the model cannot have any opset_import specified.
 
     Args:
-        model: Model to check.
-        full_check: If True, the function also checks for shapes that can be inferred.
+        model: Model to check. If model is a path, the function checks model
+            path first. If the model bytes size is larger than 2GB, function
+            should be called using model path.
+        full_check: If True, the function also runs shape inference check.
         skip_opset_compatibility_check: If True, the function skips the check for
             opset compatibility.
+        check_custom_domain: If True, the function will check all domains. Otherwise
+            only check built-in domains.
     """
     # If model is a path instead of ModelProto
     if isinstance(model, (str, os.PathLike)):
-        C.check_model_path(os.fspath(model), full_check, skip_opset_compatibility_check)
+        C.check_model_path(
+            os.fspath(model),
+            full_check,
+            skip_opset_compatibility_check,
+            check_custom_domain,
+        )
     else:
         protobuf_string = (
             model if isinstance(model, bytes) else model.SerializeToString()
@@ -145,7 +176,12 @@ def check_model(
             raise ValueError(
                 "This protobuf of onnx model is too large (>2GB). Call check_model with model path instead."
             )
-        C.check_model(protobuf_string, full_check, skip_opset_compatibility_check)
+        C.check_model(
+            protobuf_string,
+            full_check,
+            skip_opset_compatibility_check,
+            check_custom_domain,
+        )
 
 
 ValidationError = C.ValidationError

onnx/common/assertions.cc

@@ -9,6 +9,7 @@
 
 #include "onnx/common/assertions.h"
 
+#include <array>
 #include <cstdarg>
 #include <cstdio>
 
@@ -17,16 +18,20 @@
 namespace ONNX_NAMESPACE {
 
 std::string barf(const char* fmt, ...) {
-  char msg[2048];
+  constexpr size_t buffer_size = 2048;
+  std::array<char, buffer_size> msg{};
   va_list args;
 
   va_start(args, fmt);
-  // Although vsnprintf might have vulnerability issue while using format string with overflowed length,
-  // it should be safe here to use fixed length for buffer "msg". No further checking is needed.
-  vsnprintf(msg, 2048, fmt, args);
+
+  // use fixed length for buffer "msg" to avoid buffer overflow
+  vsnprintf(static_cast<char*>(msg.data()), msg.size() - 1, fmt, args);
+
+  // ensure null-terminated string to avoid out of bounds read
+  msg.back() = '\0';
   va_end(args);
 
-  return std::string(msg);
+  return std::string(msg.data());
 }
 
 void throw_assert_error(std::string& msg) {

onnx/common/common.h

@@ -34,3 +34,22 @@
 #define ONNX_CATCH(x) catch (x)
 #define ONNX_HANDLE_EXCEPTION(func) func()
 #endif
+
+// Macros to disable the copy and/or assignment methods
+// These are usually placed in the private: declarations for a class.
+
+#define ONNX_DISALLOW_COPY(TypeName) TypeName(const TypeName&) = delete
+
+#define ONNX_DISALLOW_ASSIGNMENT(TypeName) TypeName& operator=(const TypeName&) = delete
+
+#define ONNX_DISALLOW_COPY_AND_ASSIGNMENT(TypeName) \
+  ONNX_DISALLOW_COPY(TypeName);                     \
+  ONNX_DISALLOW_ASSIGNMENT(TypeName)
+
+#define ONNX_DISALLOW_MOVE(TypeName) \
+  TypeName(TypeName&&) = delete;     \
+  TypeName& operator=(TypeName&&) = delete
+
+#define ONNX_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(TypeName) \
+  ONNX_DISALLOW_COPY_AND_ASSIGNMENT(TypeName);           \
+  ONNX_DISALLOW_MOVE(TypeName)

onnx/common/file_utils.h

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <filesystem>
 #include <fstream>
 #include <string>
 
@@ -16,7 +17,8 @@ namespace ONNX_NAMESPACE {
 
 template <typename T>
 void LoadProtoFromPath(const std::string proto_path, T& proto) {
-  std::fstream proto_stream(proto_path, std::ios::in | std::ios::binary);
+  std::filesystem::path proto_u8_path = std::filesystem::u8path(proto_path);
+  std::fstream proto_stream(proto_u8_path, std::ios::in | std::ios::binary);
   if (!proto_stream.good()) {
     fail_check("Unable to open proto file: ", proto_path, ". Please check if it is a valid proto. ");
   }

onnx/common/interned_strings.h

@@ -185,7 +185,13 @@ namespace ONNX_NAMESPACE {
   _(ScatterElements)                \
   _(Resize)                         \
   _(ceil_mode)                      \
-  _(num_outputs)
+  _(num_outputs)                    \
+  _(start)                          \
+  _(end)                            \
+  _(num_groups)                     \
+  _(stash_type)                     \
+  _(block_size)                     \
+  _(output_dtype)
 
 enum BuiltinSymbol {
 #define DEFINE_SYMBOL(s) k##s,