onnx 1.17.0__cp39-cp39-macosx_12_0_universal2.whl → 1.19.0__cp39-cp39-macosx_12_0_universal2.whl

onnx/reference/reference_evaluator.py

@@ -8,10 +8,8 @@ from typing import Any
 
 import numpy as np
 
-from onnx import load
-from onnx.defs import onnx_opset_version
-from onnx.external_data_helper import ExternalDataInfo, uses_external_data
-from onnx.model_container import ModelContainer
+import onnx
+import onnx.model_container
 from onnx.onnx_pb import (
     FunctionProto,
     GraphProto,
@@ -20,13 +18,7 @@ from onnx.onnx_pb import (
     TensorProto,
     TypeProto,
 )
-from onnx.reference.op_run import (
-    OpFunctionContextDependant,
-    OpRun,
-    OpRunExpand,
-    RuntimeContextError,
-    to_array_extended,
-)
+from onnx.reference import op_run
 from onnx.reference.ops_optimized import optimized_operators
 
 
@@ -114,7 +106,7 @@ class ReferenceEvaluator:
 
             op_domain = "custom"
 
-            def _run(self, x, alpha=None):  # type: ignore
+            def _run(self, x, alpha=None):
                 # None must be the default value, it is automatically
                 # replaced by class OpRun with either the default value
                 # specified in the NodeProto or an attribute value defined
@@ -200,15 +192,15 @@ class ReferenceEvaluator:
             implementation a schema may define.
     """
 
-    def __init__(  # type: ignore
+    def __init__(
         self,
         proto: Any,
         opsets: dict[str, int] | None = None,
-        functions: list[ReferenceEvaluator | FunctionProto] | None = None,  # type: ignore
+        functions: list[ReferenceEvaluator | FunctionProto] | None = None,
         verbose: int = 0,
-        new_ops: list[OpRun] | None = None,
+        new_ops: list[type[op_run.OpRun]] | None = None,
         optimized: bool = True,
-    ):
+    ) -> None:
         if optimized:
             if new_ops is None:
                 new_ops = optimized_operators.copy()
@@ -220,17 +212,17 @@ class ReferenceEvaluator:
         self.output_types_ = None
         self.input_types_ = None
 
-        if isinstance(proto, ModelContainer):
-            self.container_ = proto
+        if isinstance(proto, onnx.model_container.ModelContainer):
+            self.container_: onnx.model_container.ModelContainer | None = proto
             proto = self.container_.model_proto
         else:
             self.container_ = None
 
         if isinstance(proto, str):
             with open(proto, "rb") as f:
-                proto = load(f)
+                proto = onnx.load(f)
         elif isinstance(proto, bytes):
-            proto = load(BytesIO(proto))
+            proto = onnx.load(BytesIO(proto))
         self.proto_ = proto
         self.functions_: dict[tuple[str, str], ReferenceEvaluator] = {}
         self.attributes_: list[str] = []
@@ -248,15 +240,17 @@ class ReferenceEvaluator:
                 raise TypeError("opsets must be a dictionary if proto is GraphProto.")
             self.opsets_ = opsets
         elif isinstance(proto, FunctionProto):
-            self.onnx_graph_ = None  # type: ignore
+            self.onnx_graph_ = None
             self.opsets_ = {d.domain: d.version for d in proto.opset_import}
             if opsets is not None:
                 raise ValueError("opsets must be None if proto is FunctionProto.")
             self.attributes_ = list(proto.attribute)
         elif isinstance(proto, NodeProto):
-            self.onnx_graph_ = None  # type: ignore
+            self.onnx_graph_ = None
             self.opsets_ = {
-                proto.domain: 1 if proto.domain != "" else onnx_opset_version()
+                proto.domain: 1
+                if proto.domain != ""
+                else onnx.defs.onnx_opset_version()
             }
         else:
             raise TypeError(f"Unexpected type {type(proto)} for proto.")
@@ -266,7 +260,7 @@ class ReferenceEvaluator:
             self.output_names_ = [o.name for o in self.onnx_graph_.output]
             self.output_types_ = [i.type for i in self.onnx_graph_.output]
             self.inits_ = list(self.onnx_graph_.initializer) + list(
-                self.onnx_graph_.sparse_initializer  # type: ignore
+                self.onnx_graph_.sparse_initializer
             )
             self.nodes_ = self.onnx_graph_.node
             all_types = {i.name: i.type for i in self.onnx_graph_.input}
@@ -283,36 +277,36 @@ class ReferenceEvaluator:
             else:
                 self.nodes_ = proto.node
         if functions is not None:
-            for f in functions:  # type: ignore
+            for f in functions:
                 if isinstance(f, FunctionProto):
                     self.functions_[f.domain, f.name] = self.__class__(
                         f, verbose=verbose, functions=list(self.functions_.values())
                     )
                 elif isinstance(f, ReferenceEvaluator):
-                    onx = f.proto_  # type: ignore
+                    onx = f.proto_
                     self.functions_[onx.domain, onx.name] = f
                 else:
                     raise TypeError(f"Unexpected type {type(f)!r} for a function.")
         self.verbose = verbose
-        self.new_ops_: dict[tuple[str, str], OpRun] = {}
+        self.new_ops_: dict[tuple[str, str], type[op_run.OpRun]] = {}
         if new_ops is not None:
             for cl in new_ops:
                 if not hasattr(cl, "op_domain"):
                     raise AttributeError(
                         f"Class {cl} must define attribute 'op_domain'."
                     )
-                if not issubclass(cl, OpRun):  # type: ignore
+                if not issubclass(cl, op_run.OpRun):
                     raise TypeError(f"Class {cl} must inherit from OpRun (in new_ops).")
-                key = cl.op_domain, cl.__name__  # type: ignore
+                key = cl.op_domain, cl.__name__
                 if key in self.new_ops_:
                     # Already an implementation, the first one is used.
                     continue
                 self.new_ops_[key] = cl
         self._init()
 
-    def retrieve_external_data(self, initializer: TensorProto) -> np.array:
+    def retrieve_external_data(self, initializer: TensorProto) -> np.ndarray:
         """Returns a tensor saved as external."""
-        info = ExternalDataInfo(initializer)
+        info = onnx.external_data_helper.ExternalDataInfo(initializer)
         location = info.location
         if self.container_ and self.container_.is_in_memory_external_initializer(
             location
@@ -349,27 +343,27 @@ class ReferenceEvaluator:
             print(pattern % tuple(new_args))
 
     @property
-    def input_names(self):  # type: ignore
+    def input_names(self):
         """Returns the input names."""
         return self.input_names_
 
     @property
-    def input_types(self):  # type: ignore
+    def input_types(self):
         """Returns the input types if any specified."""
         return self.input_types_
 
     @property
-    def output_names(self):  # type: ignore
+    def output_names(self):
         """Returns the output names."""
         return self.output_names_
 
     @property
-    def output_types(self):  # type: ignore
+    def output_types(self):
         """Returns the output types."""
         return self.output_types_
 
     @property
-    def opsets(self):  # type: ignore
+    def opsets(self):
         """Returns the opsets."""
         return self.opsets_
 
@@ -403,8 +397,8 @@ class ReferenceEvaluator:
         for init in self.inits_:
             self.rt_inits_[init.name] = (
                 self.retrieve_external_data(init)
-                if uses_external_data(init)
-                else to_array_extended(init)
+                if onnx.external_data_helper.uses_external_data(init)
+                else onnx.numpy_helper.to_array(init)
             )
         run_params = {
             "log": lambda pattern, *args: self._log(10, pattern, *args),
@@ -421,25 +415,26 @@ class ReferenceEvaluator:
                     all_types[shape_type.name] = shape_type.type
             self.all_types_ = all_types
         else:
-            self.all_types_ = None  # type: ignore
+            self.all_types_ = None
 
         for node in self.nodes_:
             try:
                 cl = self._load_impl(node)
-            except RuntimeContextError as e:
+            except op_run.RuntimeContextError as e:
                 # A node has a context dependent implementation.
                 # Shape inference must be run to get the input types.
                 if self.all_types_:
                     it = [self.get_result_types(i, exc=False) for i in node.input]
                     if None in it:
                         # One input does not exist. It must be done while executing the graph.
-                        cl = lambda *args, parent=self: OpFunctionContextDependant(  # noqa: E731
-                            *args, parent=parent
-                        )
+                        def cl(*args, parent=self):
+                            return op_run.OpFunctionContextDependant(
+                                *args, parent=parent
+                            )
                     else:
-                        cl = self._load_impl(node, it)  # type: ignore
+                        cl = self._load_impl(node, it)
                 else:
-                    raise RuntimeContextError(
+                    raise op_run.RuntimeContextError(
                         f"No implementation was found for node type {node.op_type!r} from domain {node.domain!r}. "
                         f"If this node has a context dependent implementation, you should run function infer_shapes "
                         f"before calling ReferenceEvaluator."
@@ -470,13 +465,13 @@ class ReferenceEvaluator:
             # This mechanism can be used to implement a custom onnx node
             # or to overwrite an existing one.
             cl = self.new_ops_[key]
-            if not issubclass(cl, OpRunExpand):
+            if not issubclass(cl, op_run.OpRunExpand):
                 return cl
             # It must be replaced by its implementation defined in its schema.
             expand = True
 
         if node.domain == "":
-            from onnx.reference.ops import load_op
+            from onnx.reference.ops import load_op  # noqa: PLC0415
 
             try:
                 return load_op(
@@ -486,7 +481,7 @@ class ReferenceEvaluator:
                     expand=expand,
                     evaluator_cls=self.__class__,
                 )
-            except RuntimeContextError:
+            except op_run.RuntimeContextError:
                 if input_types is None:
                     raise
                 return load_op(
@@ -494,7 +489,7 @@ class ReferenceEvaluator:
                     node.op_type,
                     version,
                     node=node,
-                    input_types=input_types,  # type: ignore[arg-type]
+                    input_types=input_types,
                     expand=expand,
                     evaluator_cls=self.__class__,
                 )
@@ -506,29 +501,29 @@ class ReferenceEvaluator:
                 f"{node.domain},{node.op_type} from the list of inlined operator."
             )
         if node.domain == "ai.onnx.preview.training":
-            from onnx.reference.ops.aionnx_preview_training import load_op as load_op_pt
-
-            return load_op_pt(
-                node.domain, node.op_type, version, evaluator_cls=self.__class__
+            from onnx.reference.ops.aionnx_preview_training import (  # noqa: PLC0415
+                load_op as load_op_pt,
             )
 
-        if node.domain == "experimental":
-            from onnx.reference.ops.experimental import load_op as load_op_exp
+            return load_op_pt(node.domain, node.op_type, version)
 
-            return load_op_exp(
-                node.domain, node.op_type, version, evaluator_cls=self.__class__
+        if node.domain == "experimental":
+            from onnx.reference.ops.experimental import (  # noqa: PLC0415
+                load_op as load_op_exp,
             )
 
-        if node.domain == "ai.onnx.ml":
-            from onnx.reference.ops.aionnxml import load_op as load_op_ml
+            return load_op_exp(node.domain, node.op_type, version)
 
-            return load_op_ml(
-                node.domain, node.op_type, version, evaluator_cls=self.__class__
+        if node.domain == "ai.onnx.ml":
+            from onnx.reference.ops.aionnxml import (  # noqa: PLC0415
+                load_op as load_op_ml,
             )
 
+            return load_op_ml(node.domain, node.op_type, version)
+
         # It has to be a function.
         if key in self.functions_:
-            from onnx.reference.ops import load_op
+            from onnx.reference.ops import load_op  # noqa: PLC0415
 
             impl = self.functions_[key]
             return load_op(
@@ -549,7 +544,7 @@ class ReferenceEvaluator:
         feed_inputs: dict[str, Any],
         attributes: dict[str, Any] | None = None,
         intermediate: bool = False,
-    ) -> dict[str, Any] | list[Any]:  # type: ignore
+    ) -> dict[str, Any] | list[Any]:
         """Executes the onnx model.
 
         Args:

onnx/serialization.py

@@ -11,7 +11,7 @@ __all__ = [
 ]
 
 import typing
-from typing import Any, Collection, Optional, Protocol, TypeVar
+from typing import Any, Optional, Protocol, TypeVar
 
 import google.protobuf.json_format
 import google.protobuf.message
@@ -19,6 +19,9 @@ import google.protobuf.text_format
 
 import onnx
 
+if typing.TYPE_CHECKING:
+    from collections.abc import Collection
+
 _Proto = TypeVar("_Proto", bound=google.protobuf.message.Message)
 # Encoding used for serializing and deserializing text files
 _ENCODING = "utf-8"
@@ -54,7 +57,7 @@ class _Registry:
     def register(self, serializer: ProtoSerializer) -> None:
         self._serializers[serializer.supported_format] = serializer
         self._extension_to_format.update(
-            {ext: serializer.supported_format for ext in serializer.file_extensions}
+            dict.fromkeys(serializer.file_extensions, serializer.supported_format)
         )
 
     def get(self, fmt: str) -> ProtoSerializer:
@@ -115,7 +118,7 @@ class _ProtobufSerializer(ProtoSerializer):
             raise TypeError(
                 f"Parameter 'serialized' must be bytes, but got type: {type(serialized)}"
             )
-        decoded = typing.cast(Optional[int], proto.ParseFromString(serialized))
+        decoded = typing.cast("Optional[int]", proto.ParseFromString(serialized))
         if decoded is not None and decoded != len(serialized):
             raise google.protobuf.message.DecodeError(
                 f"Protobuf decoding consumed too few bytes: {decoded} out of {len(serialized)}"
@@ -127,7 +130,7 @@ class _TextProtoSerializer(ProtoSerializer):
     """Serialize and deserialize text proto."""
 
     supported_format = "textproto"
-    file_extensions = frozenset({".textproto", ".prototxt", ".pbtxt"})
+    file_extensions = frozenset({".txtpb", ".textproto", ".prototxt", ".pbtxt"})
 
     def serialize_proto(self, proto: _Proto) -> bytes:
         textproto = google.protobuf.text_format.MessageToString(proto)

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);
@@ -711,7 +710,7 @@ class ShapeInferenceImplBase {
   void FinalizeShapeInference() {
     auto& errors = getErrors();
     // Throw shape inference error if any. Error mode right now only supports 0 and 1.
-    // When set to 0, any node level shape inference errors are not thrown. This is to support backward compatiblity
+    // When set to 0, any node level shape inference errors are not thrown. This is to support backward compatibility
     // with 1.7 and earlier releases. When set to 1 it will throw all exceptions.
     // TODO: Add a more granular way for exception handling.
     if (!errors.empty() && options.error_mode > 0) {
@@ -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,11 +10,17 @@ 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
+from onnx.onnx_pb import AttributeProto, FunctionProto, ModelProto, TypeProto
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+GraphInferencer = C.GraphInferencer
+InferenceContext = C.InferenceContext
 
 
 def infer_shapes(
@@ -105,7 +111,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 +127,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