onnx 1.16.2__cp312-cp312-win_amd64.whl → 1.18.0__cp312-cp312-win_amd64.whl

onnx/test/cpp/function_verify_test.cc

@@ -10,11 +10,10 @@
 #include "gtest/gtest.h"
 #include "onnx/checker.h"
 #include "onnx/common/constants.h"
+#include "onnx/defs/function.h"
 #include "onnx/defs/parser.h"
 #include "onnx/defs/printer.h"
 #include "onnx/defs/schema.h"
-#include "onnx/onnx-operators_pb.h"
-#include "onnx/onnx_pb.h"
 #include "onnx/shape_inference/implementation.h"
 
 namespace ONNX_NAMESPACE {
@@ -22,7 +21,7 @@ namespace Test {
 using namespace checker;
 using TENSOR_TYPES_MAP = std::unordered_map<std::string, std::vector<std::string>>;
 
-void GetFunctionProtoOpsetImport(
+static void GetFunctionProtoOpsetImport(
     const OpSchema& op,
     const FunctionProto* function_proto,
     std::unordered_map<std::string, int>& op_set) {
@@ -35,13 +34,13 @@ void GetFunctionProtoOpsetImport(
   }
 }
 
-void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* function_proto, int& counter) {
+static void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* function_proto, int& counter) {
   // This is a simple partial type-checker for a function-body.
   // TODO: Revisit to make the type-checker more complete.
   TENSOR_TYPES_MAP tc_map;
   std::set<std::string> primitive_types(OpSchema::all_tensor_types().begin(), OpSchema::all_tensor_types().end());
   for (const auto& input : function_op.inputs()) {
-    std::string name = input.GetName();
+    const std::string& name = input.GetName();
     auto& tvec = tc_map[name];
     for (const auto& t : input.GetTypes()) {
       tvec.emplace_back(*t);
@@ -49,7 +48,7 @@ void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* func
   }
 
   for (const auto& output : function_op.outputs()) {
-    std::string name = output.GetName();
+    const std::string& name = output.GetName();
     auto& tvec = tc_map[name];
     for (const auto& t : output.GetTypes()) {
       tvec.emplace_back(*t);
@@ -60,7 +59,7 @@ void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* func
   GetFunctionProtoOpsetImport(function_op, function_proto, op_set);
 
   for (auto& node : function_proto->node()) {
-    std::string op_type = node.op_type();
+    const std::string& op_type = node.op_type();
     std::unordered_map<std::string, int>::const_iterator it = op_set.find(node.domain());
     if (it == op_set.end()) {
       fail_check(
@@ -77,7 +76,7 @@ void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* func
     auto num_actual_inputs = static_cast<size_t>(node.input_size());
 
     for (size_t i = 0; i < num_actual_inputs; ++i) {
-      auto actual_param_name = node.input(static_cast<int>(i));
+      const auto& actual_param_name = node.input(static_cast<int>(i));
       auto iter = tc_map.find(actual_param_name);
       if (iter != tc_map.end()) {
         // if i >= num_formal_inputs, it is a variadic parameter corresponding
@@ -91,8 +90,13 @@ void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* func
         for (auto& actual_type : iter->second) {
           if (allowed_types.find(actual_type) == allowed_types.end()) {
             fail_check(
-                "Input type " + actual_type + " of parameter " + actual_param_name + " of function " +
-                function_op.Name() + " is not allowed by operator " + op_type);
+                "Input type ",
+                actual_type,
+                " of parameter ",
+                actual_param_name + " of function ",
+                function_op.Name(),
+                " is not allowed by operator ",
+                op_type);
           }
         }
       }
@@ -120,16 +124,16 @@ using AttributeValues = std::vector<AttributeProto>;
 struct FunctionOpAttributeMap {
   std::unordered_map<std::string, std::vector<AttributeValues>> map;
 
-  std::string key(std::string domain, std::string opname, int opset_version) const {
+  std::string key(const std::string& domain, const std::string& opname, int opset_version) const {
     return domain + ":" + opname + ":" + std::to_string(opset_version);
   }
 
   void addTestCase(const std::string& opname, int opset_version, std::initializer_list<const char*> attributes) {
     auto& schema_test_cases = map[key("", opname, opset_version)];
-    schema_test_cases.push_back(AttributeValues());
+    schema_test_cases.emplace_back();
     auto& test_case = schema_test_cases.back();
     for (auto attr_text : attributes) {
-      test_case.push_back(AttributeProto());
+      test_case.emplace_back();
       OnnxParser::Parse(test_case.back(), attr_text);
     }
   }
@@ -170,9 +174,9 @@ struct FunctionOpAttributeMap {
     auto it = map.find(key_value);
     if (it != map.end())
       return it->second;
-    if (schema.attributes().size() == 0) {
+    if (schema.attributes().empty()) {
       // Test with no-attributes
-      map[key_value].push_back(std::vector<AttributeProto>());
+      map[key_value].emplace_back();
     }
     return map[key_value];
   }
@@ -189,16 +193,16 @@ struct FunctionTypeChecker {
   const std::vector<AttributeValues>* attribute_cases;
 
   FunctionTypeChecker(const OpSchema& op_schema, const FunctionProto& proto)
-      : schema(op_schema), function_proto(proto) {
-    attribute_cases = &FunctionOpAttributeMap::instance().getTestCases(op_schema);
-  }
+      : schema(op_schema),
+        function_proto(proto),
+        attribute_cases(&FunctionOpAttributeMap::instance().getTestCases(op_schema)) {}
 
   // Binds each type-variable in schema to a type-value
   std::unordered_map<std::string, DataType> typeVarBindings;
 
   std::vector<std::string> errors;
 
-  void recordError(const std::string& error, AttributeValues attrs) {
+  void recordError(const std::string& error, const AttributeValues& attrs) {
     std::ostringstream ostr;
     ostr << "Type checking failed for instantiation " << schema.Name() << ":" << schema.SinceVersion() << " {";
     for (auto& pair : typeVarBindings) {
@@ -211,7 +215,7 @@ struct FunctionTypeChecker {
     errors.push_back(ostr.str());
   }
 
-  void recordSuccess(AttributeValues attrs) {
+  void recordSuccess(const AttributeValues& attrs) {
     std::cout << "Type checking succeeded for instantiation " << schema.Name() << ":" << schema.SinceVersion() << " {";
     for (auto& pair : typeVarBindings) {
       std::cout << pair.first << " = " << *pair.second << ", ";
@@ -258,7 +262,7 @@ struct FunctionTypeChecker {
 
     for (auto& attribute_vals : *attribute_cases) {
       ONNX_TRY {
-        auto output_types = shape_inference::InferFunctionOutputTypes(function_proto, input_types, attribute_vals);
+        shape_inference::InferFunctionOutputTypes(function_proto, input_types, attribute_vals);
       }
       ONNX_CATCH(ONNX_NAMESPACE::InferenceError & e) {
         ONNX_HANDLE_EXCEPTION(([&]() { recordError(e.what(), attribute_vals); }));
@@ -267,7 +271,7 @@ struct FunctionTypeChecker {
   }
 
   std::string checkAll() {
-    if (attribute_cases->size() > 0)
+    if (!attribute_cases->empty())
       forTypeVar(0);
     std::string all_errors = "";
     for (const std::string& error : errors)
@@ -276,7 +280,7 @@ struct FunctionTypeChecker {
   }
 };
 
-void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int& counter) {
+static void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int& counter) {
   // Verify function proto is valid
   if (!function_proto) {
     fail_check("Cannot get function body for op '", op.Name(), "'");
@@ -305,7 +309,7 @@ void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int
 
   FunctionTypeChecker type_checker(op, *function_proto);
   auto type_errors = type_checker.checkAll();
-  auto success = (type_errors == "");
+  auto success = (type_errors.empty());
   ASSERT_TRUE(success) << type_errors;
 }
 
@@ -314,7 +318,7 @@ void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int
 TEST(FunctionVerification, VerifyFunctionOps) {
   const std::vector<OpSchema> schemas = OpSchemaRegistry::get_all_schemas();
   int function_counter = 0, verified_counter = 0;
-  for (const auto s : schemas) {
+  for (const auto& s : schemas) {
     if (!s.HasFunction())
       continue;
     // Skip test for functions with known errors that need to be fixed:
@@ -330,11 +334,11 @@ TEST(FunctionVerification, VerifyFunctionOps) {
         VerifyFunction(s, function_body, verified_counter);
       }
     }
-    ONNX_CATCH(ONNX_NAMESPACE::checker::ValidationError e) {
+    ONNX_CATCH(const ONNX_NAMESPACE::checker::ValidationError& e) {
       ONNX_HANDLE_EXCEPTION([&]() { FAIL() << e.what(); });
     }
   }
-  std::cerr << "[          ] Verified " << verified_counter << "/" << function_counter << " Functions." << std::endl;
+  std::cerr << "[          ] Verified " << verified_counter << "/" << function_counter << " Functions." << '\n';
 }
 
 // Verify that FunctionExpandHelper obtains missing default attributes
@@ -352,7 +356,7 @@ TEST(FunctionVerification, VerifyFunctionExpandHelper) {
 
   for (const auto& node : graph.node()) {
     if (node.op_type() == "ReduceMean") {
-      auto attr = node.attribute(0);
+      const auto& attr = node.attribute(0);
       EXPECT_EQ(attr.name(), "axes");
       EXPECT_EQ(attr.ints().size(), default_axes_attribute.ints().size());
 
@@ -366,7 +370,7 @@ TEST(FunctionVerification, VerifyFunctionExpandHelper) {
          << "the default attribute `axes` has not been assigned to ReduceMean op.";
 }
 
-void RegisterFunctionSchema() {
+static void RegisterFunctionSchema() {
   ONNX_NAMESPACE::OpSchema function_schema;
   function_schema.SetName("DynamicQuantizeLinear_Fake")
       .SetDomain(AI_ONNX_ML_DOMAIN)

onnx/test/cpp/parser_test.cc

@@ -228,6 +228,44 @@ TEST(ParserTest, DomainOpCallTest) {
   Parse(n, code);
 }
 
+TEST(ParserTest, OptionalInputTest) {
+  const char* code = "x = SomeOp(y, , z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 3);
+  EXPECT_EQ(n.input(0), "y");
+  EXPECT_EQ(n.input(1), "");
+  EXPECT_EQ(n.input(2), "z");
+}
+
+TEST(ParserTest, LeadingOptionalInputTest) {
+  const char* code = "x = SomeOp( , z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 2);
+  EXPECT_EQ(n.input(0), "");
+  EXPECT_EQ(n.input(1), "z");
+}
+
+TEST(ParserTest, LeadingOptionalInputTest2) {
+  const char* code = "x = SomeOp(\"\" , z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 2);
+  EXPECT_EQ(n.input(0), "");
+  EXPECT_EQ(n.input(1), "z");
+}
+
+TEST(ParserTest, OptionalInputTest2) {
+  const char* code = "x = SomeOp(y, \"\", z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 3);
+  EXPECT_EQ(n.input(0), "y");
+  EXPECT_EQ(n.input(1), "");
+  EXPECT_EQ(n.input(2), "z");
+}
+
 TEST(ParserTest, NodeTest) {
   const char* code = "x = foo(y, z)";
   NodeProto n;
@@ -256,6 +294,23 @@ TEST(ParserTest, NodeTest) {
        )ONNX");
 }
 
+TEST(ParserTest, NodeLabelTest) {
+  const char* code = "[node1] x = foo(y, z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.name(), "node1");
+
+  NodeList nl;
+  Parse(nl, R"ONNX( {
+     [node1] x = foo(y, z)
+     [node2] w = bar(x, y)
+     s = foobar(x, w)
+  } )ONNX");
+  EXPECT_EQ(nl.Get(0).name(), "node1");
+  EXPECT_EQ(nl.Get(1).name(), "node2");
+  EXPECT_FALSE(nl.Get(2).has_name());
+}
+
 TEST(ParserTest, QualifiedOpNameTest) {
   const char* code = "x = com.example.foo(y, z)";
   NodeProto n;
@@ -663,5 +718,47 @@ agraph (float y = {1.0}, float[N] z) => (w) <
   EXPECT_EQ(graph.initializer().Get(1).external_data().Get(1).value(), "17");
 }
 
+TEST(ParserTest, QuotedIdentifiersTest) {
+  const char* code = R"ONNX(
+"a graph name" (float[N, 128] "input/X", float[128,10] "input W", float[10] B) => (float[N] C)
+{
+    "some/temp" = MatMul("input/X", "input W")
+    S = Add("some/temp", B)
+    C = Softmax(S)
+}
+)ONNX";
+
+  GraphProto graph;
+  Parse(graph, code);
+
+  EXPECT_EQ(graph.name(), "a graph name");
+  EXPECT_EQ(graph.input_size(), 3);
+  EXPECT_EQ(graph.output_size(), 1);
+  EXPECT_EQ(graph.node_size(), 3);
+  EXPECT_EQ(graph.node(0).input(0), "input/X");
+  EXPECT_EQ(graph.node(0).input(1), "input W");
+  EXPECT_EQ(graph.node(0).output(0), "some/temp");
+}
+
+TEST(ParserTest, QuotedIdentifierTest2) {
+  const char* code = R"ONNX(
+<
+  opset_import: [ "" : 10 ],
+  domain: "ai.onnx.ml",
+  doc_string: "A function test case."
+>
+"a function name" (float[N] "#y", "$z") => (float[N] "!w")
+<float[N] "/layer/x", float[N] t>
+{
+    "/layer/x" = Add("#y", "$z")
+    t = Add("/layer/x", "/layer/x")
+    "!w" = Mul(t, "#y")
+}
+)ONNX";
+
+  FunctionProto fp;
+  Parse(fp, code);
+}
+
 } // namespace Test
 } // namespace ONNX_NAMESPACE

onnx/test/cpp/schema_registration_test.cc

@@ -73,11 +73,11 @@ TEST(SchemaRegistrationTest, RegisterAndDeregisterAllOpsetSchemaVersion) {
   // Acos-7
   // Add-1,6,7,13,14
   // Trilu-14
-  auto schema = OpSchemaRegistry::Schema("Acos");
+  auto schema = OpSchemaRegistry::Schema("Acos", 7);
   EXPECT_NE(nullptr, schema);
   EXPECT_EQ(schema->SinceVersion(), 7);
 
-  schema = OpSchemaRegistry::Schema("Add");
+  schema = OpSchemaRegistry::Schema("Add", 14);
   EXPECT_NE(nullptr, schema);
   EXPECT_EQ(schema->SinceVersion(), 14);
 
@@ -121,7 +121,7 @@ TEST(SchemaRegistrationTest, RegisterSpecifiedOpsetSchemaVersion) {
   EXPECT_EQ(nullptr, opSchema);
 
   // Acos-7 is the latest Acos before specified 13
-  opSchema = OpSchemaRegistry::Schema("Acos");
+  opSchema = OpSchemaRegistry::Schema("Acos", 13);
   EXPECT_NE(nullptr, opSchema);
   EXPECT_EQ(opSchema->SinceVersion(), 7);
 #endif

onnx/test/cpp/shape_inference_test.cc

@@ -10,21 +10,22 @@
 #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;
 
 namespace ONNX_NAMESPACE {
 // onnx/defs/controlflow/old.cc
+// NOLINTNEXTLINE(misc-use-internal-linkage)
 void ScanInferenceFunctionOpset8(InferenceContext& ctx);
 // onnx/defs/controlflow/defs.cc
+// NOLINTNEXTLINE(misc-use-internal-linkage)
 void ScanInferenceFunction(InferenceContext& ctx);
 
 namespace Test {
 
 template <class Type>
-void CreateDims(Type& proto, int num_dims) {
+static void CreateDims(Type& proto, int num_dims) {
   auto mutable_shape = proto.mutable_shape();
   mutable_shape->clear_dim();
 
@@ -33,9 +34,9 @@ void CreateDims(Type& proto, int num_dims) {
 }
 
 template <class Type>
-void SetDimValues(Type& proto, const std::vector<int>& values) {
+static void SetDimValues(Type& proto, const std::vector<int>& values) {
   auto* mutable_shape = proto.mutable_shape();
-  EXPECT_TRUE(mutable_shape->dim_size() == values.size());
+  EXPECT_TRUE(static_cast<size_t>(mutable_shape->dim_size()) == values.size());
 
   int idx = 0;
   for (auto value : values) {
@@ -46,9 +47,9 @@ void SetDimValues(Type& proto, const std::vector<int>& values) {
 }
 
 template <class Type>
-void SetDimParams(Type& proto, const std::vector<const std::string*>& values) {
+static void SetDimParams(Type& proto, const std::vector<const std::string*>& values) {
   auto mutable_shape = proto.mutable_shape();
-  EXPECT_TRUE(mutable_shape->dim_size() == values.size());
+  EXPECT_TRUE(static_cast<size_t>(mutable_shape->dim_size()) == values.size());
 
   int idx = 0;
   for (auto value : values) {
@@ -59,12 +60,12 @@ void SetDimParams(Type& proto, const std::vector<const std::string*>& values) {
 }
 
 template <class Type>
-void Dump(const Type& t) {
+static void Dump(const Type& t) {
   auto& s_shape = t.shape();
   auto num_dims = s_shape.dim_size();
   std::cout << num_dims << " dims. ";
   for (int i = 0; i < num_dims; ++i) {
-    auto x = s_shape.dim(0);
+    const auto& x = s_shape.dim(0);
     auto y = x.has_dim_value();
     auto z = x.has_dim_param();
 
@@ -343,7 +344,7 @@ TEST(ShapeInferenceTest, mergeShapeInfo_Mismatches) {
 
 // Check subgraph inferencing via GraphInferencer using a Scan
 static void doInferencingTest(bool use_scan_opset8) {
-  auto* schemaRegistry = OpSchemaRegistry::Instance();
+  OpSchemaRegistry::Instance();
   GraphProto subgraph;
 
   // simple tensor without shape info
@@ -507,8 +508,7 @@ TEST(GraphInferencerImplTest, Scan9_BasicTest) {
   doInferencingTest(false);
 }
 
-void RunReshapeShapeInfTest(const char* modelStr, TensorShapeProto& expectedShape) {
-  ModelProto model;
+static void ParseAndInfer(ModelProto& model, const char* modelStr) {
   OnnxParser parser(modelStr);
   auto status = parser.Parse(model);
   EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
@@ -516,6 +516,11 @@ void RunReshapeShapeInfTest(const char* modelStr, TensorShapeProto& expectedShap
 
   ShapeInferenceOptions options{true, 1, true};
   ONNX_NAMESPACE::shape_inference::InferShapes(model, ONNX_NAMESPACE::OpSchemaRegistry::Instance(), options);
+}
+
+static void RunReshapeShapeInfTest(const char* modelStr, TensorShapeProto& expectedShape) {
+  ModelProto model;
+  ParseAndInfer(model, modelStr);
 
   const auto inferredShape = model.graph().output(0).type().tensor_type().shape();
   EXPECT_TRUE(inferredShape.dim_size() == expectedShape.dim_size());
@@ -620,5 +625,37 @@ TEST(ShapeInferenceTest, CheckShapesAndTypesTest) {
 #endif
 }
 
+TEST(ShapeInferenceTest, CustomOpTest) {
+  const char* modelStr = R"ONNX(
+<ir_version: 8,  opset_import: ["" : 15, "custom.domain" : 1]>
+agraph (float[256, 768, 3] x) => (z1, z2)
+{
+    z1 = custom.domain.CustomOp (x)
+    # Inference cannot determine the type/shape of z1
+    z2 = Abs(x)
+    # Inference SHOULD determine the type/shape of z2 (same as that of x)
+}
+)ONNX";
+
+  ModelProto model;
+  ParseAndInfer(model, modelStr);
+
+  auto& z1_value_info = model.graph().output(0);
+  // Check no inferred type for z1 (It's a quirk of the implementation that it
+  // has a dummy TypeProto, but it should have no values filled in.)
+  ASSERT_TRUE(z1_value_info.has_type());
+  ASSERT_FALSE(z1_value_info.type().has_tensor_type());
+
+  // Check inferred type for z2:
+  auto& z2_value_info = model.graph().output(1);
+  ASSERT_TRUE(z2_value_info.has_type());
+  ASSERT_TRUE(z2_value_info.type().has_tensor_type());
+  EXPECT_EQ(z2_value_info.type().tensor_type().elem_type(), TensorProto_DataType_FLOAT);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim_size(), 3);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim(0).dim_value(), 256);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim(1).dim_value(), 768);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim(2).dim_value(), 3);
+}
+
 } // namespace Test
 } // namespace ONNX_NAMESPACE

onnx/test/cpp/test_main.cc

@@ -9,7 +9,7 @@
 #include "gtest/gtest.h"
 
 GTEST_API_ int main(int argc, char** argv) {
-  std::cout << "Running main() from test_main.cc" << std::endl;
+  std::cout << "Running main() from test_main.cc" << '\n';
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

onnx/test/cpp/utf8_conversion_test.cc

@@ -0,0 +1,27 @@
+// Copyright (c) ONNX Project Contributors
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifdef _WIN32
+#include <string>
+
+#include "gtest/gtest.h"
+#include "onnx/common/path.h"
+namespace ONNX_NAMESPACE::Test {
+
+TEST(UTF8Test, WideStringConvertion) {
+  std::string utf8_str(u8"世界，你好！");
+  EXPECT_EQ(ONNX_NAMESPACE::wstring_to_utf8str(ONNX_NAMESPACE::utf8str_to_wstring(utf8_str)), utf8_str);
+}
+
+TEST(UTF8Test, TryConvertUTF8) {
+  std::string utf8_str(u8"世界，你好！");
+  auto wstr = ONNX_NAMESPACE::utf8str_to_wstring(utf8_str);
+  auto wstr2 = ONNX_NAMESPACE::utf8str_to_wstring(
+      std::string(reinterpret_cast<const char*>(wstr.c_str()), sizeof(std::wstring::value_type) * wstr.size()), true);
+  EXPECT_EQ(wstr, wstr2);
+}
+} // namespace ONNX_NAMESPACE::Test
+#endif

onnx/test/data_propagation_test.py

@@ -6,7 +6,6 @@ from __future__ import annotations
 
 import unittest
 
-# TODO: remove the following ignore after mypy upgrade in ONNX
 from shape_inference_test import TestShapeInferenceHelper
 
 import onnx.parser
@@ -54,7 +53,7 @@ class TestDataPropagation(TestShapeInferenceHelper):
                 make_tensor_value_info("y", TensorProto.INT32, (3, 4, 5)),
             ],
             data_prop=True,
-        )  # type: ignore
+        )
 
     def test_model_data_propagation(self) -> None:
         """Infer the shape of z by propagating the value of xshape."""
@@ -132,6 +131,121 @@ class TestDataPropagation(TestShapeInferenceHelper):
             data_prop=True,
         )
 
+    def test_shape_arithmetic(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("y", TensorProto.FLOAT, (1, 2, 3))],
+            [
+                make_node("Shape", ["x"], ["xshape"]),
+                make_node("Shape", ["y"], ["yshape"]),
+                make_node("Add", ["xshape", "yshape"], ["zshape"]),
+                make_node(
+                    "ConstantOfShape",
+                    ["zshape"],
+                    ["z"],
+                    value=make_tensor("value", TensorProto.INT32, (1,), (2,)),
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("xshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("yshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("zshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("z", TensorProto.INT32, (4, 6, 8)),
+            ],
+            data_prop=True,
+        )
+
+    def test_shape_arithmetic_with_broadcast(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("y", TensorProto.FLOAT, (3,))],
+            [
+                make_node("Shape", ["x"], ["xshape"]),
+                make_node("Shape", ["y"], ["yshape"]),
+                make_node("Add", ["xshape", "yshape"], ["zshape"]),
+                make_node(
+                    "ConstantOfShape",
+                    ["zshape"],
+                    ["z"],
+                    value=make_tensor("value", TensorProto.INT32, (1,), (2,)),
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("xshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("yshape", TensorProto.INT64, (1,)),
+                make_tensor_value_info("zshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("z", TensorProto.INT32, (6, 7, 8)),
+            ],
+            data_prop=True,
+        )
+
+    def test_shape_arithmetic_with_zero_broadcast(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ()), ("y", TensorProto.FLOAT, (3,))],
+            [
+                make_node("Shape", ["x"], ["xshape"]),
+                make_node("Shape", ["y"], ["yshape"]),
+                make_node("Add", ["xshape", "yshape"], ["zshape"]),
+                make_node(
+                    "ConstantOfShape",
+                    ["zshape"],
+                    ["z"],
+                    value=make_tensor("value", TensorProto.INT32, (1,), (2,)),
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("xshape", TensorProto.INT64, (0,)),
+                make_tensor_value_info("yshape", TensorProto.INT64, (1,)),
+                make_tensor_value_info("zshape", TensorProto.INT64, (0,)),
+                make_tensor_value_info("z", TensorProto.INT32, ()),
+            ],
+            data_prop=True,
+        )
+
+    def test_empty_tensor(self) -> None:
+        """Test that a Concat with an empty tensor as input is handled correctly by data-propagation."""
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[256] y) => (float[N] z)
+            <float[0] x = {}>
+            {
+                z = Concat <axis=0> (x, y)
+            }
+        """
+        )
+        inferred_model = onnx.shape_inference.infer_shapes(model, True, True, True)
+        output = inferred_model.graph.output[0]
+        self.assertEqual(output.type.tensor_type.shape.dim[0].dim_value, 256)
+
+    def test_empty_tensor_negative_axis(self) -> None:
+        """Test that a Concat with an empty tensor as input is handled correctly by data-propagation.
+        This time with a negative axis.
+        """
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[256] y) => (float[N] z)
+            <float[0] x = {}>
+            {
+                z = Concat <axis=-1> (x, y)
+            }
+        """
+        )
+        inferred_model = onnx.shape_inference.infer_shapes(model, True, True, True)
+        output = inferred_model.graph.output[0]
+        self.assertEqual(output.type.tensor_type.shape.dim[0].dim_value, 256)
+
 
 if __name__ == "__main__":
     unittest.main()

onnx/test/function_inference_test.py

@@ -1,8 +1,10 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
 import unittest
-from typing import Sequence
+from typing import TYPE_CHECKING
 
 from shape_inference_test import TestShapeInferenceHelper
 
@@ -12,6 +14,9 @@ import onnx.parser
 import onnx.shape_inference
 from onnx import AttributeProto, TypeProto
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 float_type_ = onnx.helper.make_tensor_type_proto(1, None)
 uint8_type_ = onnx.helper.make_tensor_type_proto(2, None)
 int8_type_ = onnx.helper.make_tensor_type_proto(3, None)