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

onnx/common/tensor.h

@@ -18,18 +18,17 @@
 
 #include "onnx/common/assertions.h"
 #include "onnx/onnx_pb.h"
-#include "onnx/string_utils.h"
 
 namespace ONNX_NAMESPACE {
 
 struct Tensor final {
  private:
-  bool is_segment_;
-  int64_t segment_begin_;
-  int64_t segment_end_;
-  bool has_name_;
+  bool is_segment_{false};
+  int64_t segment_begin_{0};
+  int64_t segment_end_{0};
+  bool has_name_{false};
   std::string name_;
-  int32_t elem_type_;
+  int32_t elem_type_{ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED};
   std::vector<int64_t> sizes_;
 
   std::vector<float> float_data_;
@@ -39,66 +38,10 @@ struct Tensor final {
   std::vector<uint64_t> uint64_data_;
   std::vector<std::string> string_data_;
 
-  bool is_raw_data_;
+  bool is_raw_data_{false};
   std::string raw_data_;
 
  public:
-  Tensor()
-      : is_segment_(false),
-        segment_begin_(0),
-        segment_end_(0),
-        has_name_(false),
-        elem_type_(ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED),
-        is_raw_data_(false) {}
-
-  Tensor(const Tensor& other)
-      : is_segment_(other.is_segment_),
-        segment_begin_(other.segment_begin_),
-        segment_end_(other.segment_end_),
-        has_name_(other.has_name_),
-        elem_type_(other.elem_type_),
-        sizes_(other.sizes_),
-        float_data_(other.float_data_),
-        double_data_(other.double_data_),
-        int32_data_(other.int32_data_),
-        int64_data_(other.int64_data_),
-        uint64_data_(other.uint64_data_),
-        is_raw_data_(other.is_raw_data_) {
-    // Deep copy. Avoid copy on write when using gcc<5.0
-    string_data_.resize(other.string_data_.size());
-    for (unsigned int i = 0; i < other.string_data_.size(); ++i) {
-      string_data_[i] = std::string(other.string_data_[i].data(), other.string_data_[i].size());
-    }
-    name_ = std::string(other.name_.data(), other.name_.size());
-    raw_data_ = std::string(other.raw_data_.data(), other.raw_data_.size());
-  }
-  Tensor(Tensor&&) = default;
-  ~Tensor() = default;
-
-  friend void swap(Tensor& first, Tensor& second) {
-    using std::swap;
-    swap(first.is_segment_, second.is_segment_);
-    swap(first.segment_begin_, second.segment_begin_);
-    swap(first.segment_end_, second.segment_end_);
-    swap(first.has_name_, second.has_name_);
-    swap(first.name_, second.name_);
-    swap(first.elem_type_, second.elem_type_);
-    swap(first.sizes_, second.sizes_);
-    swap(first.float_data_, second.float_data_);
-    swap(first.double_data_, second.double_data_);
-    swap(first.int32_data_, second.int32_data_);
-    swap(first.int64_data_, second.int64_data_);
-    swap(first.uint64_data_, second.uint64_data_);
-    swap(first.is_raw_data_, second.is_raw_data_);
-    swap(first.string_data_, second.string_data_);
-    swap(first.raw_data_, second.raw_data_);
-  }
-
-  Tensor& operator=(Tensor other) noexcept {
-    swap(*this, other);
-    return *this;
-  }
-
   const std::vector<int64_t>& sizes() const {
     return sizes_;
   }
@@ -242,30 +185,30 @@ inline const std::string* Tensor::data<std::string>() const {
   return string_data_.data();
 }
 
-#define define_data(type, field)                             \
-  template <>                                                \
-  inline type* Tensor::data<type>() {                        \
-    if (is_raw_data_) {                                      \
-      return (type*)const_cast<char*>(&raw_data_.data()[0]); \
-    } else {                                                 \
-      return field.data();                                   \
-    }                                                        \
-  }                                                          \
-                                                             \
-  template <>                                                \
-  inline const type* Tensor::data<type>() const {            \
-    if (is_raw_data_) {                                      \
-      return (const type*)(raw_data_.data());                \
-    } else {                                                 \
-      return field.data();                                   \
-    }                                                        \
-  }
-
-define_data(float, float_data_);
-define_data(double, double_data_);
-define_data(int32_t, int32_data_);
-define_data(int64_t, int64_data_);
-define_data(uint64_t, uint64_data_);
+#define define_data(type, field)                              \
+  template <>                                                 \
+  inline type* Tensor::data<type>() {                         \
+    if (is_raw_data_) {                                       \
+      return reinterpret_cast<type*>(raw_data_.data());       \
+    } else {                                                  \
+      return field.data();                                    \
+    }                                                         \
+  }                                                           \
+                                                              \
+  template <>                                                 \
+  inline const type* Tensor::data<type>() const {             \
+    if (is_raw_data_) {                                       \
+      return reinterpret_cast<const type*>(raw_data_.data()); \
+    } else {                                                  \
+      return field.data();                                    \
+    }                                                         \
+  }
+
+define_data(float, float_data_)
+define_data(double, double_data_)
+define_data(int32_t, int32_data_)
+define_data(int64_t, int64_data_)
+define_data(uint64_t, uint64_data_)
 #undef define_data
 
 } // namespace ONNX_NAMESPACE

onnx/common/version.h

@@ -9,6 +9,6 @@
 namespace ONNX_NAMESPACE {
 
 // Represents the most recent release version. Updated with every release.
-constexpr const char* LAST_RELEASE_VERSION = "1.16.2";
+constexpr const char* LAST_RELEASE_VERSION = "1.18.0";
 
 } // namespace ONNX_NAMESPACE

onnx/common/visitor.h

@@ -67,7 +67,7 @@ struct Visitor {
     return true;
   }
 
-  virtual ~Visitor() {}
+  virtual ~Visitor() = default;
 };
 
 // MutableVisitor: A version of Visitor that allows mutation of the visited objects.
@@ -122,7 +122,7 @@ struct MutableVisitor {
     return true;
   }
 
-  virtual ~MutableVisitor() {}
+  virtual ~MutableVisitor() = default;
 };
 
 } // namespace internal

onnx/compose.py

@@ -1,16 +1,27 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
+from typing import TYPE_CHECKING
 
-from typing import Dict, List, MutableMapping, Optional, Set, Tuple
+from onnx import (
+    AttributeProto,
+    GraphProto,
+    ModelProto,
+    TensorProto,
+    checker,
+    helper,
+    utils,
+)
 
-from onnx import GraphProto, ModelProto, TensorProto, checker, helper, utils
+if TYPE_CHECKING:
+    from collections.abc import MutableMapping
 
 
 def check_overlapping_names(
-    g1: GraphProto, g2: GraphProto, io_map: Optional[List[Tuple[str, str]]] = None
-) -> List[Tuple[str, List[str]]]:
+    g1: GraphProto, g2: GraphProto, io_map: list[tuple[str, str]] | None = None
+) -> list[tuple[str, list[str]]]:
     """Checks whether there are name collisions between two graphs
 
     Returns a list of tuples where the first element represents the member containing overlapping names
@@ -20,25 +31,25 @@ def check_overlapping_names(
     Optionally, it takes an io_map, representing the output/inputs to be connected. It provided, overlapping
     present in the io_map argument will be ignored.
     """
-    if type(g1) is not GraphProto:
-        raise ValueError("g1 argument is not an ONNX graph")
-    if type(g2) is not GraphProto:
-        raise ValueError("g2 argument is not an ONNX graph")
+    if not isinstance(g1, GraphProto):
+        raise TypeError("g1 argument is not an ONNX graph")
+    if not isinstance(g2, GraphProto):
+        raise TypeError("g2 argument is not an ONNX graph")
 
-    def _overlapping(c1: List[str], c2: List[str]) -> List[str]:
+    def _overlapping(c1: list[str], c2: list[str]) -> list[str]:
         return list(set(c1) & set(c2))
 
-    def _edge_names(graph: GraphProto, exclude: Optional[Set[str]] = None) -> List[str]:
+    def _edge_names(graph: GraphProto, exclude: set[str] | None = None) -> list[str]:
         if exclude is None:
             exclude = set()
         edges = []
         for n in graph.node:
             for i in n.input:
                 if i != "" and i not in exclude:
-                    edges.append(i)
+                    edges.append(i)  # noqa: PERF401
             for o in n.output:
                 if o != "" and o not in exclude:
-                    edges.append(o)
+                    edges.append(o)  # noqa: PERF401
         return edges
 
     result = []
@@ -80,13 +91,13 @@ def check_overlapping_names(
 def merge_graphs(
     g1: GraphProto,
     g2: GraphProto,
-    io_map: List[Tuple[str, str]],
-    inputs: Optional[List[str]] = None,
-    outputs: Optional[List[str]] = None,
-    prefix1: Optional[str] = None,
-    prefix2: Optional[str] = None,
-    name: Optional[str] = None,
-    doc_string: Optional[str] = None,
+    io_map: list[tuple[str, str]],
+    inputs: list[str] | None = None,
+    outputs: list[str] | None = None,
+    prefix1: str | None = None,
+    prefix2: str | None = None,
+    name: str | None = None,
+    doc_string: str | None = None,
 ) -> GraphProto:
     """Combines two ONNX graphs into a single one.
 
@@ -115,10 +126,10 @@ def merge_graphs(
     Returns:
         GraphProto
     """
-    if type(g1) is not GraphProto:
-        raise ValueError("g1 argument is not an ONNX graph")
-    if type(g2) is not GraphProto:
-        raise ValueError("g2 argument is not an ONNX graph")
+    if not isinstance(g1, GraphProto):
+        raise TypeError("g1 argument is not an ONNX graph")
+    if not isinstance(g2, GraphProto):
+        raise TypeError("g2 argument is not an ONNX graph")
 
     # Prefixing names in the graph if requested, adjusting io_map accordingly
     if prefix1 or prefix2:
@@ -206,12 +217,20 @@ def merge_graphs(
     g.node.extend(g2.node)
     g2_nodes_end = len(g.node)
 
+    # Search inputs of the subgraph recursively
+    def connect_io(sub_graph: GraphProto, start: int, end: int) -> None:
+        for node_idx in range(start, end):
+            node = sub_graph.node[node_idx]
+            for attr in node.attribute:
+                if attr.type == AttributeProto.GRAPH:
+                    connect_io(attr.g, 0, len(attr.g.node))
+
+            for index, name_ in enumerate(node.input):
+                if name_ in reversed_io_map:
+                    node.input[index] = reversed_io_map[name_]
+
     # Connecting outputs of the first graph with the inputs of the second
-    for node_idx in range(g2_nodes_begin, g2_nodes_end):
-        node = g.node[node_idx]
-        for index, name_ in enumerate(node.input):
-            if name_ in reversed_io_map:
-                node.input[index] = reversed_io_map[name_]
+    connect_io(g, g2_nodes_begin, g2_nodes_end)
 
     if inputs:
         input_set = set(inputs)
@@ -267,17 +286,17 @@ def merge_graphs(
 def merge_models(
     m1: ModelProto,
     m2: ModelProto,
-    io_map: List[Tuple[str, str]],
-    inputs: Optional[List[str]] = None,
-    outputs: Optional[List[str]] = None,
-    prefix1: Optional[str] = None,
-    prefix2: Optional[str] = None,
-    name: Optional[str] = None,
-    doc_string: Optional[str] = None,
-    producer_name: Optional[str] = "onnx.compose.merge_models",
-    producer_version: Optional[str] = "1.0",
-    domain: Optional[str] = "",
-    model_version: Optional[int] = 1,
+    io_map: list[tuple[str, str]],
+    inputs: list[str] | None = None,
+    outputs: list[str] | None = None,
+    prefix1: str | None = None,
+    prefix2: str | None = None,
+    name: str | None = None,
+    doc_string: str | None = None,
+    producer_name: str | None = "onnx.compose.merge_models",
+    producer_version: str | None = "1.0",
+    domain: str | None = "",
+    model_version: int | None = 1,
 ) -> ModelProto:
     """Combines two ONNX models into a single one.
 
@@ -313,10 +332,10 @@ def merge_models(
     Returns:
         ModelProto
     """
-    if type(m1) is not ModelProto:
-        raise ValueError("m1 argument is not an ONNX model")
-    if type(m2) is not ModelProto:
-        raise ValueError("m2 argument is not an ONNX model")
+    if not isinstance(m1, ModelProto):
+        raise TypeError("m1 argument is not an ONNX model")
+    if not isinstance(m2, ModelProto):
+        raise TypeError("m2 argument is not an ONNX model")
 
     if m1.ir_version != m2.ir_version:
         raise ValueError(
@@ -413,14 +432,14 @@ def merge_models(
 def add_prefix_graph(
     graph: GraphProto,
     prefix: str,
-    rename_nodes: Optional[bool] = True,
-    rename_edges: Optional[bool] = True,
-    rename_inputs: Optional[bool] = True,
-    rename_outputs: Optional[bool] = True,
-    rename_initializers: Optional[bool] = True,
-    rename_value_infos: Optional[bool] = True,
-    inplace: Optional[bool] = False,
-    name_map: Optional[Dict[str, str]] = None,
+    rename_nodes: bool | None = True,
+    rename_edges: bool | None = True,
+    rename_inputs: bool | None = True,
+    rename_outputs: bool | None = True,
+    rename_initializers: bool | None = True,
+    rename_value_infos: bool | None = True,
+    inplace: bool | None = False,
+    name_map: dict[str, str] | None = None,
 ) -> GraphProto:
     """Adds a prefix to names of elements in a graph: nodes, edges, inputs, outputs,
     initializers, sparse initializer, value infos.
@@ -444,8 +463,8 @@ def add_prefix_graph(
     Returns:
         GraphProto
     """
-    if type(graph) is not GraphProto:
-        raise ValueError("graph argument is not an ONNX graph")
+    if not isinstance(graph, GraphProto):
+        raise TypeError("graph argument is not an ONNX graph")
 
     if not inplace:
         g = GraphProto()
@@ -530,14 +549,14 @@ def add_prefix_graph(
 def add_prefix(
     model: ModelProto,
     prefix: str,
-    rename_nodes: Optional[bool] = True,
-    rename_edges: Optional[bool] = True,
-    rename_inputs: Optional[bool] = True,
-    rename_outputs: Optional[bool] = True,
-    rename_initializers: Optional[bool] = True,
-    rename_value_infos: Optional[bool] = True,
-    rename_functions: Optional[bool] = True,
-    inplace: Optional[bool] = False,
+    rename_nodes: bool | None = True,
+    rename_edges: bool | None = True,
+    rename_inputs: bool | None = True,
+    rename_outputs: bool | None = True,
+    rename_initializers: bool | None = True,
+    rename_value_infos: bool | None = True,
+    rename_functions: bool | None = True,
+    inplace: bool | None = False,
 ) -> ModelProto:
     """Adds a prefix to names of elements in a graph: nodes, edges, inputs, outputs,
     initializers, sparse initializer, value infos, and local functions.
@@ -561,8 +580,8 @@ def add_prefix(
     Returns:
         ModelProto
     """
-    if type(model) is not ModelProto:
-        raise ValueError("model argument is not an ONNX model")
+    if not isinstance(model, ModelProto):
+        raise TypeError("model argument is not an ONNX model")
 
     if not inplace:
         m = ModelProto()
@@ -604,7 +623,7 @@ def add_prefix(
 def expand_out_dim_graph(
     graph: GraphProto,
     dim_idx: int,
-    inplace: Optional[bool] = False,
+    inplace: bool | None = False,
 ) -> GraphProto:
     """Inserts an extra dimension with extent 1 to each output in the graph.
 
@@ -621,8 +640,8 @@ def expand_out_dim_graph(
     Returns:
         GraphProto
     """
-    if type(graph) is not GraphProto:
-        raise ValueError("graph argument is not an ONNX graph")
+    if not isinstance(graph, GraphProto):
+        raise TypeError("graph argument is not an ONNX graph")
 
     if not inplace:
         g = GraphProto()
@@ -684,7 +703,7 @@ def expand_out_dim_graph(
 def expand_out_dim(
     model: ModelProto,
     dim_idx: int,
-    inplace: Optional[bool] = False,
+    inplace: bool | None = False,
 ) -> ModelProto:
     """Inserts an extra dimension with extent 1 to each output in the graph.
 
@@ -701,8 +720,8 @@ def expand_out_dim(
     Returns:
         ModelProto
     """
-    if type(model) is not ModelProto:
-        raise ValueError("model argument is not an ONNX model")
+    if not isinstance(model, ModelProto):
+        raise TypeError("model argument is not an ONNX model")
 
     if not inplace:
         m = ModelProto()

onnx/cpp2py_export.cc

@@ -7,11 +7,13 @@
 
 #include <climits>
 #include <limits>
+#include <string>
 #include <tuple>
 #include <unordered_map>
+#include <utility>
 
 #include "onnx/checker.h"
-#include "onnx/defs/function.h"
+#include "onnx/common/ir_pb_converter.h"
 #include "onnx/defs/parser.h"
 #include "onnx/defs/printer.h"
 #include "onnx/defs/schema.h"
@@ -20,6 +22,10 @@
 #include "onnx/shape_inference/implementation.h"
 #include "onnx/version_converter/convert.h"
 
+#if (PYBIND11_VERSION_MAJOR != 2 || PYBIND11_VERSION_MINOR < 12)
+#pragma error "Pybind11 must be >= 2.12 to be compatible with numpy 2.0."
+#endif
+
 namespace ONNX_NAMESPACE {
 namespace py = pybind11;
 using namespace pybind11::literals;
@@ -41,26 +47,27 @@ static std::string ProtoBytesToText(const py::bytes& bytes) {
   return ProtoToString(proto);
 }
 
-template <typename T, typename Ts = typename std::remove_const<T>::type>
-std::pair<std::unique_ptr<Ts[]>, std::unordered_map<std::string, T*>> ParseProtoFromBytesMap(
-    std::unordered_map<std::string, py::bytes> bytesMap) {
-  std::unique_ptr<Ts[]> values(new Ts[bytesMap.size()]);
+template <typename T, typename Ts = std::remove_const_t<T>>
+static std::pair<std::vector<Ts>, std::unordered_map<std::string, T*>> ParseProtoFromBytesMap(
+    const std::unordered_map<std::string, py::bytes>& bytesMap) {
+  std::vector<Ts> values(bytesMap.size());
   std::unordered_map<std::string, T*> result;
   size_t i = 0;
-  for (auto kv : bytesMap) {
+  for (const auto& kv : bytesMap) {
     ParseProtoFromPyBytes(&values[i], kv.second);
     result[kv.first] = &values[i];
     i++;
   }
+  // C++ guarantees that the pointers remain valid after std::vector<Ts> is moved.
   return std::make_pair(std::move(values), result);
 }
 
-std::unordered_map<std::string, py::bytes> CallNodeInferenceFunction(
+static std::unordered_map<std::string, py::bytes> CallNodeInferenceFunction(
     OpSchema* schema,
     const py::bytes& nodeBytes,
-    std::unordered_map<std::string, py::bytes> valueTypesByNameBytes,
-    std::unordered_map<std::string, py::bytes> inputDataByNameBytes,
-    std::unordered_map<std::string, py::bytes> inputSparseDataByNameBytes,
+    const std::unordered_map<std::string, py::bytes>& valueTypesByNameBytes,
+    const std::unordered_map<std::string, py::bytes>& inputDataByNameBytes,
+    const std::unordered_map<std::string, py::bytes>& inputSparseDataByNameBytes,
     std::unordered_map<std::string, int> opsetImports,
     const int irVersion) {
   NodeProto node{};
@@ -96,7 +103,7 @@ std::unordered_map<std::string, py::bytes> CallNodeInferenceFunction(
     if (proto.IsInitialized()) {
       std::string s;
       proto.SerializeToString(&s);
-      typeProtoBytes[node.output(i)] = py::bytes(s);
+      typeProtoBytes[node.output(static_cast<int>(i))] = py::bytes(s);
     }
   }
 
@@ -240,7 +247,7 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
           py::init([](std::string name,
                       std::string domain,
                       int since_version,
-                      std::string doc,
+                      const std::string& doc,
                       std::vector<OpSchema::FormalParameter> inputs,
                       std::vector<OpSchema::FormalParameter> outputs,
                       std::vector<std::tuple<std::string, std::vector<std::string>, std::string>> type_constraints,
@@ -568,8 +575,10 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
   checker.def(
       "check_model_path",
       (void (*)(
-          const std::string& path, bool full_check, bool skip_opset_compatibility_check, bool check_custom_domain)) &
-          checker::check_model,
+          const std::string& path,
+          bool full_check,
+          bool skip_opset_compatibility_check,
+          bool check_custom_domain))&checker::check_model,
       "path"_a,
       "full_check"_a = false,
       "skip_opset_compatibility_check"_a = false,
@@ -582,7 +591,7 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
   version_converter.doc() = "VersionConverter submodule";
   py::register_exception<ConvertError>(version_converter, "ConvertError");
 
-  version_converter.def("convert_version", [](const py::bytes& bytes, py::int_ target) {
+  version_converter.def("convert_version", [](const py::bytes& bytes, const py::int_& target) {
     ModelProto proto{};
     ParseProtoFromPyBytes(&proto, bytes);
     shape_inference::InferShapes(proto);
@@ -630,7 +639,7 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
       [](const py::bytes& bytes, bool check_type, bool strict_mode, bool data_prop) {
         ModelProto proto{};
         ParseProtoFromPyBytes(&proto, bytes);
-        ShapeInferenceOptions options{check_type, strict_mode == true ? 1 : 0, data_prop};
+        ShapeInferenceOptions options{check_type, strict_mode ? 1 : 0, data_prop};
         shape_inference::InferShapes(proto, OpSchemaRegistry::Instance(), options);
         std::string out;
         proto.SerializeToString(&out);
@@ -648,15 +657,15 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
          bool check_type,
          bool strict_mode,
          bool data_prop) -> void {
-        ShapeInferenceOptions options{check_type, strict_mode == true ? 1 : 0, data_prop};
+        ShapeInferenceOptions options{check_type, strict_mode ? 1 : 0, data_prop};
         shape_inference::InferShapes(model_path, output_path, OpSchemaRegistry::Instance(), options);
       });
 
   shape_inference.def(
       "infer_function_output_types",
       [](const py::bytes& function_proto_bytes,
-         const std::vector<py::bytes> input_types_bytes,
-         const std::vector<py::bytes> attributes_bytes) -> std::vector<py::bytes> {
+         const std::vector<py::bytes>& input_types_bytes,
+         const std::vector<py::bytes>& attributes_bytes) -> std::vector<py::bytes> {
         FunctionProto proto{};
         ParseProtoFromPyBytes(&proto, function_proto_bytes);
 
@@ -682,7 +691,7 @@ PYBIND11_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
         for (auto& type_proto : output_types) {
           std::string out;
           type_proto.SerializeToString(&out);
-          result.push_back(py::bytes(out));
+          result.emplace_back(out);
         }
         return result;
       });

onnx/defs/__init__.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 __all__ = [
     "C",
@@ -19,7 +20,6 @@ __all__ = [
     "SchemaError",
 ]
 
-from typing import List
 
 import onnx.onnx_cpp2py_export.defs as C  # noqa: N812
 from onnx import AttributeProto, FunctionProto
@@ -47,18 +47,18 @@ def onnx_ml_opset_version() -> int:
 
 
 @property  # type: ignore
-def _function_proto(self):  # type: ignore
+def _function_proto(self):
     func_proto = FunctionProto()
     func_proto.ParseFromString(self._function_body)
     return func_proto
 
 
-OpSchema = C.OpSchema  # type: ignore
+OpSchema = C.OpSchema
 OpSchema.function_body = _function_proto  # type: ignore
 
 
 @property  # type: ignore
-def _attribute_default_value(self):  # type: ignore
+def _attribute_default_value(self):
     attr = AttributeProto()
     attr.ParseFromString(self._default_value)
     return attr
@@ -116,10 +116,14 @@ def _op_schema_attribute_repr(self) -> str:
 OpSchema.Attribute.__repr__ = _op_schema_attribute_repr  # type: ignore
 
 
-def get_function_ops() -> List[OpSchema]:
+def get_function_ops() -> list[OpSchema]:
     """Return operators defined as functions."""
     schemas = C.get_all_schemas()
-    return [schema for schema in schemas if schema.has_function or schema.has_context_dependent_function]  # type: ignore
+    return [
+        schema
+        for schema in schemas
+        if schema.has_function or schema.has_context_dependent_function  # type: ignore[attr-defined]
+    ]
 
 
 SchemaError = C.SchemaError