onnx 1.17.0__cp39-cp39-macosx_12_0_universal2.whl → 1.18.0__cp39-cp39-macosx_12_0_universal2.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.17.0";
+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

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-from typing import MutableMapping
+from typing import TYPE_CHECKING
 
 from onnx import (
     AttributeProto,
@@ -15,6 +15,9 @@ from onnx import (
     utils,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import MutableMapping
+
 
 def check_overlapping_names(
     g1: GraphProto, g2: GraphProto, io_map: list[tuple[str, str]] | None = None
@@ -28,10 +31,10 @@ 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]:
         return list(set(c1) & set(c2))
@@ -123,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:
@@ -329,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(
@@ -460,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()
@@ -577,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()
@@ -637,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()
@@ -717,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"
@@ -45,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{};
@@ -100,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);
     }
   }
 
@@ -244,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,
@@ -572,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,
@@ -586,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);
@@ -634,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);
@@ -652,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);
 
@@ -686,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

@@ -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
@@ -119,7 +119,11 @@ OpSchema.Attribute.__repr__ = _op_schema_attribute_repr  # type: ignore
 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

onnx/defs/controlflow/defs.cc

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <assert.h>
+#include <cassert>
 
 #include "onnx/defs/controlflow/utils.h"
 #include "onnx/defs/schema.h"
@@ -12,10 +12,10 @@
 namespace ONNX_NAMESPACE {
 using SupportType = OpSchema::SupportType;
 
-static std::vector<std::string> control_flow_types_ir10() {
-  auto t = OpSchema::all_tensor_types_ir10();
-  auto s = OpSchema::all_tensor_sequence_types_ir10();
-  auto o = OpSchema::all_optional_types_ir10();
+static std::vector<std::string> control_flow_types_ir11() {
+  auto t = OpSchema::all_tensor_types_ir11();
+  auto s = OpSchema::all_tensor_sequence_types_ir11();
+  auto o = OpSchema::all_optional_types_ir11();
   t.insert(t.end(), s.begin(), s.end());
   t.insert(t.end(), o.begin(), o.end());
   return t;
@@ -23,7 +23,7 @@ static std::vector<std::string> control_flow_types_ir10() {
 
 ONNX_OPERATOR_SET_SCHEMA(
     If,
-    21,
+    23,
     OpSchema()
         .SetDoc("If conditional")
         .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
@@ -63,8 +63,8 @@ ONNX_OPERATOR_SET_SCHEMA(
             AttributeProto::GRAPH)
         .TypeConstraint(
             "V",
-            control_flow_types_ir10(),
-            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv10.")
+            control_flow_types_ir11(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv11.")
         .TypeConstraint("B", {"tensor(bool)"}, "Only bool")
         .TypeAndShapeInferenceFunction(IfInferenceFunction));
 
@@ -208,7 +208,7 @@ The input/output of subgraph (produced by loop node) matching is based on order
 
 ONNX_OPERATOR_SET_SCHEMA(
     Loop,
-    21,
+    23,
     OpSchema()
         .SetDoc(Loop_ver16_doc)
         .Input(
@@ -253,8 +253,8 @@ ONNX_OPERATOR_SET_SCHEMA(
             AttributeProto::GRAPH)
         .TypeConstraint(
             "V",
-            control_flow_types_ir10(),
-            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv10.")
+            control_flow_types_ir11(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv11.")
         .TypeConstraint("I", {"tensor(int64)"}, "tensor of int64, which should be a scalar.")
         .TypeConstraint("B", {"tensor(bool)"}, "tensor of bool, which should be a scalar.")
         .TypeAndShapeInferenceFunction(LoopInferenceFunction));
@@ -385,7 +385,7 @@ values are computed in the outer graph, they need to be passed in as extra state
 
 ONNX_OPERATOR_SET_SCHEMA(
     Scan,
-    21,
+    23,
     OpSchema()
         .SetDoc(scan_16_doc)
         .Input(
@@ -448,7 +448,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             "range is [-r, r-1].",
             AttributeProto::INTS,
             false)
-        .TypeConstraint("V", OpSchema::all_tensor_types_ir10(), "All Tensor types up to IRv10.")
+        .TypeConstraint("V", OpSchema::all_tensor_types_ir11(), "All Tensor types up to IRv11.")
         .TypeAndShapeInferenceFunction(ScanInferenceFunction)); // Shares same shape inference as opset 11
 
 } // namespace ONNX_NAMESPACE