onnx 1.17.0__cp312-cp312-win32.whl → 1.18.0__cp312-cp312-win32.whl

onnx/shape_inference/attribute_binder.h

@@ -16,7 +16,7 @@ using AttributeMap = std::unordered_map<std::string, const AttributeProto*>;
 
 class AttributeBinder : public MutableVisitor {
  public:
-  AttributeBinder(const AttributeMap& attr_map) : attr_map_(attr_map) {}
+  explicit AttributeBinder(const AttributeMap& attr_map) : attr_map_(attr_map) {}
 
   // Binding a formal attribute-parameter to a value may, as a special case, also
   // remove the attribute from the list of attributes of a node (when the attribute

onnx/shape_inference/implementation.cc

@@ -16,7 +16,6 @@
 #include "onnx/common/common.h"
 #include "onnx/common/file_utils.h"
 #include "onnx/defs/data_type_utils.h"
-#include "onnx/proto_utils.h"
 #include "onnx/shape_inference/attribute_binder.h"
 #include "onnx/string_utils.h"
 
@@ -73,7 +72,7 @@ inline bool IsOnnxDomainOp(const NodeProto& node, const std::string& op_type) {
 } // namespace
 
 template <class T>
-void CheckTensorShapesAndTypes(const T& inferred_type, const T& existing_type) {
+static void CheckTensorShapesAndTypes(const T& inferred_type, const T& existing_type) {
   if (inferred_type.elem_type() != TensorProto::UNDEFINED && existing_type.elem_type() != TensorProto::UNDEFINED &&
       existing_type.elem_type() != inferred_type.elem_type()) {
     std::stringstream ss;
@@ -250,20 +249,20 @@ void MaterializeSymbolicShape(TypeProto* inferred_type, SymbolTable& symbol_tabl
   }
 }
 
-std::string GetFunctionIdentifier(const FunctionProto& function) {
+static std::string GetFunctionIdentifier(const FunctionProto& function) {
   // Note: Models with IR version < 10 do not have the overload attribute.
   // However, that will be mapped to an empty identifier.
-  std::string overload = function.overload();
+  const std::string& overload = function.overload();
   if (overload.empty()) {
     return function.domain() + ":" + function.name();
   }
   return function.domain() + ":" + function.name() + ":" + overload;
 }
 
-std::string GetFunctionIdentifier(const NodeProto& node) {
+static std::string GetFunctionIdentifier(const NodeProto& node) {
   // Note: Models with IR version < 10 do not have the overload attribute.
   // However, that will be mapped to an empty identifier.
-  std::string overload = node.overload();
+  const std::string& overload = node.overload();
   if (overload.empty()) {
     return node.domain() + ":" + node.op_type();
   }
@@ -304,7 +303,7 @@ class InferredTypes {
 };
 
 // Initialize a DataValueMap for a called function from the DataValueMap of the caller
-void BindValuesOnCall(
+static void BindValuesOnCall(
     const DataValueMap& caller_map,
     const NodeProto& caller,
     DataValueMap& callee_map,
@@ -323,7 +322,7 @@ void BindValuesOnCall(
 }
 
 // Update a DataValueMap for a calling function from the DataValueMap of the callee
-void BindValuesOnReturn(
+static void BindValuesOnReturn(
     const DataValueMap& callee_map,
     const FunctionProto& callee,
     DataValueMap& caller_map,
@@ -482,7 +481,7 @@ class ShapeInferenceImplBase {
         if (options.check_type) {
           schema->CheckInputOutputType(ctx);
         }
-      } else if (model_local_functions_map.size() > 0) {
+      } else if (!model_local_functions_map.empty()) {
         auto iter = model_local_functions_map.find(GetFunctionIdentifier(n));
         if (iter != model_local_functions_map.end()) {
           ProcessCall(n, *(iter->second), ctx);
@@ -787,7 +786,7 @@ static void InferShapesImpl(
 
 // Either ModelProto or FunctionProto
 template <class T>
-std::unordered_map<std::string, int> GetOpsetImportsFromProto(const T& proto) {
+static std::unordered_map<std::string, int> GetOpsetImportsFromProto(const T& proto) {
   std::unordered_map<std::string, int> opset_imports;
   for (const auto& opset_import : proto.opset_import()) {
     opset_imports[opset_import.domain()] = static_cast<int>(opset_import.version());
@@ -912,7 +911,7 @@ struct FunctionInferenceContext : public InferenceContext {
     }
     auto num_outputs = func_proto.output_size();
     for (int i = 0; i < num_outputs; i++) {
-      output_types_.push_back(TypeProto());
+      output_types_.emplace_back();
     }
   }
 

onnx/shape_inference/implementation.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <map>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -12,9 +11,8 @@
 #include <utility>
 #include <vector>
 
-#include "onnx/defs/function.h"
 #include "onnx/defs/schema.h"
-#include "onnx/proto_utils.h"
+#include "onnx/defs/tensor_proto_util.h"
 #include "onnx/string_utils.h"
 
 namespace ONNX_NAMESPACE {
@@ -31,7 +29,7 @@ using DataValueMap = std::unordered_map<std::string, TensorShapeProto>;
 
 class SymbolTableImpl : public SymbolTable {
  public:
-  SymbolTableImpl() : index_(0) {}
+  SymbolTableImpl() = default;
 
   void addFromGraph(const GraphProto& g) override {
     AddExistingSymbolicDims(g.input());
@@ -50,7 +48,7 @@ class SymbolTableImpl : public SymbolTable {
   }
 
  private:
-  unsigned int index_;
+  unsigned int index_{0};
   std::unordered_set<std::string> existing_symbols;
 
   // TypeProto_Tensor or TypeProto_SparseTensor
@@ -98,14 +96,14 @@ class SymbolTableImpl : public SymbolTable {
 struct GraphInferenceContext {
   GraphInferenceContext(
       const std::unordered_map<std::string, TypeProto*>& outer_scope_value_types_by_name_in,
-      const std::unordered_map<std::string, int> opset_imports_in,
+      std::unordered_map<std::string, int> opset_imports_in,
       SymbolTable* symbol_table_in = nullptr,
       const ModelLocalFunctionsMap& model_local_functions_in = {},
       const ISchemaRegistry* schema_registry_in = OpSchemaRegistry::Instance(),
       DataValueMap* generated_shape_data_by_name_in = nullptr,
       const int ir_version_in = IR_VERSION)
       : outer_scope_value_types_by_name{&outer_scope_value_types_by_name_in},
-        opset_imports{opset_imports_in},
+        opset_imports{std::move(opset_imports_in)},
         symbol_table{symbol_table_in},
         model_local_functions{model_local_functions_in},
         schema_registry{schema_registry_in},
@@ -265,9 +263,8 @@ struct InferenceContextImpl : public InferenceContext {
         fail_type_inference("Attribute ", attr_name, " does not contain a graph.");
       }
 
-      std::unique_ptr<GraphInferencer> new_inferencer{
-          new GraphInferencerImpl(*attrNameToGraphProto->second, *graphInferenceContext_, options_)};
-
+      auto new_inferencer =
+          std::make_unique<GraphInferencerImpl>(*attrNameToGraphProto->second, *graphInferenceContext_, options_);
       inferencer = new_inferencer.get();
       graphAttributeInferencers_.emplace(attr_name, std::move(new_inferencer));
     } else {
@@ -416,6 +413,27 @@ struct DataPropagationContextImpl : public DataPropagationContext {
         return &(result.first->second);
       }
     }
+
+    // If X has a known rank N, then X's value can be represented as an array
+    // of N unknown values (represented as a TensorShapeProto).
+    const TypeProto* type = getInputType(index);
+    if ((type != nullptr) && (type->has_tensor_type())) {
+      auto& tensor_type = type->tensor_type();
+      if (tensor_type.has_shape()) {
+        const TensorShapeProto& shape = tensor_type.shape();
+        if ((shape.dim_size() == 1) && (shape.dim(0).has_dim_value())) {
+          TensorShapeProto tsp;
+          int64_t dim_value = shape.dim(0).dim_value();
+          for (int64_t i = 0; i < dim_value; ++i) {
+            tsp.add_dim();
+          }
+          auto result = generatedShapeData_.insert({input_name, std::move(tsp)});
+          if (result.second) {
+            return &(result.first->second);
+          }
+        }
+      }
+    }
     return nullptr;
   }
 
@@ -459,24 +477,24 @@ void mergeShapesAndTypes(const TypeProto& inferredType, TypeProto* existingType)
 /// ModelLocalFunctionsMap is a map of function id -> model local function proto
 /// All the ONNX helper utilities expect the function id == <function_proto.domain>:<function_proto.name>
 ///
-void InferShapes(
+ONNX_API void InferShapes(
     GraphProto* g,
     const std::unordered_map<std::string, int>& opset_imports,
     const ISchemaRegistry* schema_registry = OpSchemaRegistry::Instance(),
-    const ShapeInferenceOptions& options = {},
+    const ShapeInferenceOptions& options = ShapeInferenceOptions(),
     const ModelLocalFunctionsMap& in_model_functions = {});
 
-void InferShapes(
+ONNX_API void InferShapes(
     ModelProto& m,
     const ISchemaRegistry* schema_registry = OpSchemaRegistry::Instance(),
-    const ShapeInferenceOptions& options = {},
+    const ShapeInferenceOptions& options = ShapeInferenceOptions(),
     DataValueMap* generated_shape_data_by_name = nullptr);
 
-void InferShapes(
+ONNX_API void InferShapes(
     const std::string& model_path,
     const std::string& save_path = "",
     const ISchemaRegistry* schema_registry = OpSchemaRegistry::Instance(),
-    const ShapeInferenceOptions& options = {},
+    const ShapeInferenceOptions& options = ShapeInferenceOptions(),
     DataValueMap* generated_shape_data_by_name = nullptr);
 
 ///
@@ -487,7 +505,7 @@ void InferShapeForFunctionNode(
     const FunctionProto& func,
     const ISchemaRegistry* schema_registry,
     InferenceContext& ctx,
-    const ShapeInferenceOptions& options = {},
+    const ShapeInferenceOptions& options = ShapeInferenceOptions(),
     const ModelLocalFunctionsMap& model_local_functions_map = {},
     SymbolTable* symbolTable = nullptr,
     DataValueMap* generated_shape_data_by_name = nullptr);
@@ -501,7 +519,7 @@ void InferShapeForFunctionNode(
     const std::unordered_map<std::string, int>& func_opset_imports,
     const ISchemaRegistry* schema_registry,
     InferenceContext& ctx,
-    const ShapeInferenceOptions& options = {},
+    const ShapeInferenceOptions& options = ShapeInferenceOptions(),
     const ModelLocalFunctionsMap& model_local_functions_map = {},
     SymbolTable* symbolTable = nullptr,
     DataValueMap* generated_shape_data_by_name = nullptr);

onnx/shape_inference.py

@@ -10,12 +10,15 @@ complete.
 from __future__ import annotations
 
 import os
-from typing import Sequence
+from typing import TYPE_CHECKING
 
 import onnx
 import onnx.onnx_cpp2py_export.shape_inference as C  # noqa: N812
 from onnx import AttributeProto, FunctionProto, ModelProto, TypeProto
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 def infer_shapes(
     model: ModelProto | bytes,
@@ -105,7 +108,7 @@ def infer_node_outputs(
     opset_imports: list[onnx.OperatorSetIdProto] | None = None,
     ir_version: int = onnx.IR_VERSION,
 ) -> dict[str, onnx.TypeProto]:
-    if not schema.has_type_and_shape_inference_function:  # type: ignore
+    if not schema.has_type_and_shape_inference_function:
         return {}
     if input_data is None:
         input_data = {}
@@ -121,9 +124,9 @@ def infer_node_outputs(
         key: input_types[key].SerializeToString() for key in node.input if key != ""
     }
     # input_types will also be used as outer_scope_value_types so do not filter by node's input here
-    for key in input_types:
+    for key, value in input_types.items():
         if key not in passed_input_types:
-            passed_input_types[key] = input_types[key].SerializeToString()
+            passed_input_types[key] = value.SerializeToString()
     passed_input_data = {
         key: input_data[key].SerializeToString()
         for key in node.input

onnx/subbyte.py

@@ -3,7 +3,14 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
+import typing
+
 import numpy as np
+import numpy.typing as npt
+import typing_extensions
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Sequence
 
 INT4_MIN = -8
 INT4_MAX = 7
@@ -11,7 +18,15 @@ UINT4_MIN = 0
 UINT4_MAX = 15
 
 
-def float32_to_4bit_unpacked(
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def float32_to_4bit_unpacked(*args, **kwargs):
+    return _float32_to_4bit_unpacked(*args, **kwargs)
+
+
+def _float32_to_4bit_unpacked(
     x: np.ndarray | np.dtype | float, signed: bool
 ) -> np.ndarray:
     """Cast to 4bit via rounding and clipping (without packing).
@@ -33,7 +48,15 @@ def float32_to_4bit_unpacked(
     return np.rint(clipped).astype(dtype)  # type: ignore[no-any-return]
 
 
-def float32x2_to_4bitx2(
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def float32x2_to_4bitx2(*args, **kwargs):
+    return _float32x2_to_4bitx2(*args, **kwargs)
+
+
+def _float32x2_to_4bitx2(
     val_low: np.dtype, val_high: np.dtype, signed: bool
 ) -> np.ndarray:
     """Cast two elements to 4bit (via rounding and clipping) and pack
@@ -46,15 +69,60 @@ def float32x2_to_4bitx2(
     Returns:
         An ndarray with a single int8/uint8 element, containing both int4 elements
     """
-    i8_high = float32_to_4bit_unpacked(val_high, signed)
-    i8_low = float32_to_4bit_unpacked(val_low, signed)
-    return i8_high << 4 | i8_low & 0x0F  # type: ignore[operator]
+    i8_high = _float32_to_4bit_unpacked(val_high, signed)
+    i8_low = _float32_to_4bit_unpacked(val_low, signed)
+    return i8_high << 4 | i8_low & 0x0F
+
+
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def unpack_4bitx2(*args, **kwargs):
+    return _unpack_4bitx2(*args, **kwargs)
 
 
-def unpack_single_4bitx2(
+def _unpack_4bitx2(
+    x: npt.NDArray[np.uint8], dims: int | Sequence[int]
+) -> npt.NDArray[np.uint8]:
+    """Unpack an array of packed uint8 elements (4bitx2) into individual elements
+    (still represented as uint8)
+
+    Args:
+        x: Input data
+        dims: The shape of the output array.
+
+    Returns:
+        A array containing unpacked 4-bit elements (as int8/uint8)
+    """
+    res = np.empty([x.size * 2], dtype=np.uint8)
+    x_low = x & np.uint8(0x0F)
+    x_high = x & np.uint8(0xF0)
+    x_high >>= np.uint8(4)
+    res[0::2] = x_low
+    res[1::2] = x_high
+    if (
+        res.size == np.prod(dims) + 1
+    ):  # handle single-element padding due to odd number of elements
+        res = res.ravel()[:-1]
+    res = res.reshape(dims)
+    return res
+
+
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def unpack_single_4bitx2(*args, **kwargs):
+    return _unpack_single_4bitx2(*args, **kwargs)
+
+
+def _unpack_single_4bitx2(
     x: np.ndarray | np.dtype | float, signed: bool
 ) -> tuple[np.ndarray, np.ndarray]:
-    unpack_signed = lambda x: np.where((x >> 3) == 0, x, x | 0xF0)  # noqa: E731
+    def unpack_signed(x):
+        return np.where((x >> 3) == 0, x, x | 0xF0)
+
     """Unpack a single byte 4bitx2 to two 4 bit elements
     Args:
         x: Input data
@@ -70,3 +138,57 @@ def unpack_single_4bitx2(
     x_high = unpack_signed(x_high) if signed else x_high
     dtype = np.int8 if signed else np.uint8
     return (x_low.astype(dtype), x_high.astype(dtype))
+
+
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def float32_to_float4e2m1_unpacked(*args, **kwargs):
+    return _float32_to_float4e2m1_unpacked(*args, **kwargs)
+
+
+def _float32_to_float4e2m1_unpacked(values: np.ndarray) -> np.ndarray:
+    """Cast float32 to float4e2m1 (without packing).
+
+    Args:
+        values: element or array to be converted
+
+    Returns:
+        An ndarray with unpacked float4e2m1 elements (as uint8)
+    """
+    sign = np.where(np.signbit(values), 0x8, 0x0).astype(np.uint8)
+    magnitude = np.abs(values)
+    res = np.zeros(values.shape, dtype=np.uint8)
+    res[(magnitude > 0.25) & (magnitude < 0.75)] = 0x1  # noqa: PLR2004
+    res[(magnitude >= 0.75) & (magnitude <= 1.25)] = 0x2  # noqa: PLR2004
+    res[(magnitude > 1.25) & (magnitude < 1.75)] = 0x3  # noqa: PLR2004
+    res[(magnitude >= 1.75) & (magnitude <= 2.5)] = 0x4  # noqa: PLR2004
+    res[(magnitude > 2.5) & (magnitude < 3.5)] = 0x5  # noqa: PLR2004
+    res[(magnitude >= 3.5) & (magnitude <= 5.0)] = 0x6  # noqa: PLR2004
+    res[magnitude > 5.0] = 0x7  # noqa: PLR2004
+    res |= sign
+    res[np.isnan(values)] = 0x7
+    return res
+
+
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def float32x2_to_float4e2m1x2(*args, **kwargs):
+    return _float32x2_to_float4e2m1x2(*args, **kwargs)
+
+
+def _float32x2_to_float4e2m1x2(val_low: np.ndarray, val_high: np.ndarray) -> np.ndarray:
+    """Cast two elements to float4e2m1 and pack to a single byte
+    Args:
+        val_low: element to be packed in the 4 LSB
+        val_high: element to be packed in the 4 MSB
+
+    Returns:
+        An ndarray with uint8 elements, containing both float4e2m1 elements
+    """
+    i8_high = _float32_to_float4e2m1_unpacked(val_high)
+    i8_low = _float32_to_float4e2m1_unpacked(val_low)
+    return i8_high << 4 | i8_low & 0x0F

onnx/test/checker_test.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import os
 import tempfile
 import unittest
-from typing import Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -22,6 +22,9 @@ from onnx import (
     shape_inference,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 class TestChecker(unittest.TestCase):
     @property

onnx/test/compose_test.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 import unittest
-from typing import Callable, Sequence
+from typing import TYPE_CHECKING, Callable
 
 import numpy as np
 
@@ -23,6 +23,9 @@ from onnx import (
     version_converter,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 def _load_model(m_def: str) -> ModelProto:
     """Parses a model from a string representation, including checking the model for correctness"""

onnx/test/cpp/data_propagation_test.cc

@@ -4,14 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <iostream>
-
 #include "gtest/gtest.h"
-#include "onnx/checker.h"
 #include "onnx/defs/parser.h"
 #include "onnx/defs/schema.h"
-#include "onnx/defs/shape_inference.h"
-#include "onnx/onnx_pb.h"
 #include "onnx/shape_inference/implementation.h"
 
 using namespace ONNX_NAMESPACE::shape_inference;
@@ -20,7 +15,7 @@ namespace ONNX_NAMESPACE {
 
 namespace Test {
 
-inline bool CompareShape(
+static bool CompareShape(
     const TensorShapeProto& inferredShape,
     const TensorShapeProto& expectedShape,
     bool checkSameParam = false) {
@@ -43,7 +38,7 @@ inline bool CompareShape(
   return true;
 }
 
-TensorShapeProto RunDataPropagation(const char* graphCode, int domainVersion = 15) {
+static TensorShapeProto RunDataPropagation(const char* graphCode, int domainVersion = 15) {
   // Parses the graph from graphCode
   GraphProto graph;
   OnnxParser parser(graphCode);
@@ -303,6 +298,23 @@ agraph (int32[1,2] x, int32[3,4] y) => (int32[4] w)
   EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
 }
 
+TEST(DataPropagationImplTest, DynamicConcatTest) {
+  const char* code = R"ONNX(
+agraph (float[32, 1024] x, int64[2] dynamic_shape) => (int64[4] z)
+{
+    xs = Shape(x)   # [32, 1024]
+    z = Concat<axis = 0>(xs, dynamic_shape)  # [32, 1024, ?, ?]
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(32);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(1024);
+  expected_tsp.mutable_dim()->Add();
+  expected_tsp.mutable_dim()->Add();
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
 TEST(DataPropagationImplTest, GatherTest) {
   const char* code = R"ONNX(
 agraph (int32[1,2,3,4,5,6] x) => (int32[3] w)

onnx/test/cpp/function_context_test.cc

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <iostream>
+#include <stdexcept>
 
 #include "gtest/gtest.h"
 #include "onnx/checker.h"
@@ -14,15 +14,12 @@
 
 using namespace ONNX_NAMESPACE::checker;
 
-#pragma warning(push)
-#pragma warning(disable : 4530)
-
 namespace ONNX_NAMESPACE {
 namespace Test {
 
 // Utilities. TODO: Turn them into reusable ONNX utilities for use by
 
-TensorProto ToTensor(double value, TensorProto_DataType elem_type) {
+static TensorProto ToTensor(double value, TensorProto_DataType elem_type) {
   TensorProto t;
   t.set_data_type(elem_type);
   switch (elem_type) {
@@ -42,9 +39,8 @@ TensorProto ToTensor(double value, TensorProto_DataType elem_type) {
   return t;
 }
 
-void BuildNodes(FunctionProto& functionProto, const std::vector<FunctionBodyHelper::NodeDef>& node_defs) {
-  for (size_t i = 0; i < node_defs.size(); i++) {
-    const FunctionBodyHelper::NodeDef& node = node_defs[i];
+static void BuildNodes(FunctionProto& functionProto, const std::vector<FunctionBodyHelper::NodeDef>& node_defs) {
+  for (const auto& node : node_defs) {
     auto* np = functionProto.add_node();
 
     np->set_op_type(node.op_type);
@@ -60,7 +56,7 @@ void BuildNodes(FunctionProto& functionProto, const std::vector<FunctionBodyHelp
   }
 }
 
-bool BuildFunctionProto(
+static bool BuildFunctionProto(
     FunctionProto& functionProto,
     const OpSchema& schema,
     const std::vector<FunctionBodyHelper::NodeDef>& node_defs) {
@@ -71,7 +67,7 @@ bool BuildFunctionProto(
 
 // A monomorphic context-dependent function test-case.
 static bool
-BuildFloatFunctionBody(const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) {
+BuildFloatFunctionBody(const FunctionBodyBuildContext& /*ctx*/, const OpSchema& schema, FunctionProto& functionProto) {
   // Create a scalar-tensor constant 2.0 of float type:
   auto two_as_tensor = ToTensor(2.0, TensorProto_DataType::TensorProto_DataType_FLOAT);
 
@@ -82,7 +78,7 @@ BuildFloatFunctionBody(const FunctionBodyBuildContext& ctx, const OpSchema& sche
   return BuildFunctionProto(functionProto, schema, body);
 }
 
-void RegisterCustomFuncFloatSchema() {
+static void RegisterCustomFuncFloatSchema() {
   ONNX_NAMESPACE::OpSchema schema;
   schema.SetName("CustomFuncFloat")
       .SetDomain(ONNX_DOMAIN)
@@ -141,7 +137,7 @@ BuildFunctionBody(const FunctionBodyBuildContext& ctx, const OpSchema& schema, F
   return BuildFunctionProto(functionProto, schema, body);
 }
 
-void RegisterCustomFunctionSchema() {
+static void RegisterCustomFunctionSchema() {
   ONNX_NAMESPACE::OpSchema schema;
   schema.SetName("CustomFunction")
       .SetDomain(ONNX_DOMAIN)
@@ -220,7 +216,7 @@ TEST(FunctionAPITest, VersionedFunctionBodyTest) {
   const auto* schema2 = OpSchemaRegistry::Schema("MySub", 2, ONNX_DOMAIN);
   EXPECT_TRUE(schema2);
   for (int model_opset_import = 2; model_opset_import < 9; model_opset_import++) {
-    try {
+    ONNX_TRY {
       bool validate = true;
       const FunctionProto* function = schema2->GetFunction(model_opset_import, validate);
       if (model_opset_import >= 6) { // function body should be updated at opset 6 where Sub is updated
@@ -228,19 +224,23 @@ TEST(FunctionAPITest, VersionedFunctionBodyTest) {
       } else {
         ASSERT_TRUE(function);
       }
-    } catch (std::runtime_error err) {
-      ASSERT_TRUE(model_opset_import == 6 || model_opset_import == 7 || model_opset_import == 8);
+    }
+    ONNX_CATCH(const std::runtime_error&) {
+      ONNX_HANDLE_EXCEPTION(
+          [&]() { ASSERT_TRUE(model_opset_import == 6 || model_opset_import == 7 || model_opset_import == 8); });
     }
   }
 
   const auto* schema9 = OpSchemaRegistry::Schema("MySub", 9, ONNX_DOMAIN);
   EXPECT_TRUE(schema9);
   for (int model_opset_import = 9; model_opset_import < 10; model_opset_import++) {
-    try {
+    ONNX_TRY {
       const FunctionProto* function = schema9->GetFunction(model_opset_import);
       ASSERT_TRUE(function);
-    } catch (std::runtime_error err) {
-      ASSERT_TRUE(model_opset_import == 13 || model_opset_import == 14 || model_opset_import == 15);
+    }
+    ONNX_CATCH(const std::runtime_error&) {
+      ONNX_HANDLE_EXCEPTION(
+          [&]() { ASSERT_TRUE(model_opset_import == 13 || model_opset_import == 14 || model_opset_import == 15); });
     }
   }
 }
@@ -276,4 +276,3 @@ TEST(FunctionAPITest, TypeContextTest) {
 
 } // namespace Test
 } // namespace ONNX_NAMESPACE
-#pragma warning(pop)