onnx 1.17.0__cp39-cp39-win_amd64.whl → 1.19.0__cp39-cp39-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,13 @@ 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;
-  }
+  std::vector<std::pair<std::string, std::string>> external_data_;
+  ONNX_NAMESPACE::TensorProto_DataLocation data_location_{ONNX_NAMESPACE::TensorProto_DataLocation_DEFAULT};
 
+ public:
   const std::vector<int64_t>& sizes() const {
     return sizes_;
   }
@@ -114,7 +60,7 @@ struct Tensor final {
     if (dim < 0) {
       dim += (int)sizes_.size();
     }
-    ONNX_ASSERT(dim >= 0 && (size_t)dim < sizes_.size());
+    ONNX_ASSERT(dim >= 0 && (size_t)dim < sizes_.size())
     return std::accumulate(sizes_.begin() + dim, sizes_.end(), (int64_t)1, std::multiplies<int64_t>{});
   }
 
@@ -223,6 +169,26 @@ struct Tensor final {
   bool is_raw_data() const {
     return is_raw_data_;
   }
+
+  const std::vector<std::pair<std::string, std::string>>& external_data() const {
+    return external_data_;
+  }
+
+  std::vector<std::pair<std::string, std::string>>& external_data() {
+    return external_data_;
+  }
+
+  bool has_data_location() const {
+    return data_location_ != ONNX_NAMESPACE::TensorProto_DataLocation_DEFAULT;
+  }
+
+  const ONNX_NAMESPACE::TensorProto_DataLocation& data_location() const {
+    return data_location_;
+  }
+
+  ONNX_NAMESPACE::TensorProto_DataLocation& data_location() {
+    return data_location_;
+  }
 };
 
 template <>
@@ -230,7 +196,7 @@ inline std::string* Tensor::data<std::string>() {
   ONNX_ASSERTM(
       !is_raw_data(),
       "data type is string. string content is required to be stored in repeated bytes string_data field."
-      "raw_data type cannot be string.");
+      "raw_data type cannot be string.")
   return string_data_.data();
 }
 template <>
@@ -238,34 +204,34 @@ inline const std::string* Tensor::data<std::string>() const {
   ONNX_ASSERTM(
       !is_raw_data(),
       "data type is string. string content is required to be stored in repeated bytes string_data field."
-      "raw_data type cannot be string.");
+      "raw_data type cannot be string.")
   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.19.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))
@@ -116,17 +119,17 @@ def merge_graphs(
         prefix1 (string): Optional prefix to be added to all names in g1
         prefix2 (string): Optional prefix to be added to all names in g2
         name (string): Optional name for the combined graph
-                       By default, the name is g1.name and g2.name concatenated with an undescore delimiter
+                       By default, the name is g1.name and g2.name concatenated with an underscore delimiter
         doc_string (string): Optional docstring for the combined graph
                              If not provided, a default docstring with the concatenation of g1 and g2 docstrings is used
 
     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:
@@ -318,7 +321,7 @@ def merge_models(
         prefix1 (string): Optional prefix to be added to all names in m1
         prefix2 (string): Optional prefix to be added to all names in m2
         name (string): Optional name for the combined graph
-                       By default, the name is g1.name and g2.name concatenated with an undescore delimiter
+                       By default, the name is g1.name and g2.name concatenated with an underscore delimiter
         doc_string (string): Optional docstring for the combined graph
                              If not provided, a default docstring with the concatenation of g1 and g2 docstrings is used
         producer_name (string): Optional producer name for the combined model. Default: 'onnx.compose'
@@ -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()
@@ -474,12 +477,16 @@ def add_prefix_graph(
 
     if name_map is None:
         name_map = {}
+
     if rename_edges:
+        # See https://github.com/onnx/onnx/pull/6869#issuecomment-2852719536.
+        # Consider only intermediate nodes, that are not connected to graph outputs.
+        # Rename graph inputs or outputs separately based on rename_inputs/rename_outputs flags.
+        graph_output_names = {o.name for o in g.output}
         for n in g.node:
-            for e in n.input:
-                name_map[e] = _prefixed(prefix, e)
             for e in n.output:
-                name_map[e] = _prefixed(prefix, e)
+                if e not in graph_output_names:
+                    name_map[e] = _prefixed(prefix, e)
 
     if rename_inputs:
         for entry in g.input:
@@ -577,8 +584,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 +644,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 +724,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()