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

onnx/common/ir_pb_converter.cc

@@ -20,9 +20,9 @@
 namespace ONNX_NAMESPACE {
 
 // Part 1: convert ONNX Protobuf to IR
-std::unique_ptr<Graph> graphProtoToGraph(const GraphProto& gp, bool nested, const int ir_version = IR_VERSION);
+static std::unique_ptr<Graph> graphProtoToGraph(const GraphProto& gp, bool nested, const int ir_version = IR_VERSION);
 
-Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
+static Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
   Tensor ret;
 
   ret.sizes().reserve(tp.dims_size());
@@ -43,6 +43,8 @@ Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT16:
     case ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16:
     case ONNX_NAMESPACE::TensorProto_DataType_BOOL:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT4:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT4:
     case ONNX_NAMESPACE::TensorProto_DataType_INT8:
     case ONNX_NAMESPACE::TensorProto_DataType_INT16:
     case ONNX_NAMESPACE::TensorProto_DataType_INT32:
@@ -51,7 +53,9 @@ Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FN:
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FNUZ:
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2:
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2FNUZ: {
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E8M0:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT4E2M1: {
       ret.int32s().reserve(tp.int32_data_size());
       for (int i = 0; i < tp.int32_data_size(); i++) {
         ret.int32s().push_back(tp.int32_data(i));
@@ -89,6 +93,8 @@ Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
       break;
     }
     case ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED:
+      [[fallthrough]];
+    default:
       fail_convert("Unknown tensor data type");
   }
 
@@ -104,10 +110,17 @@ Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
   if (tp.has_segment()) {
     ret.set_segment_begin_and_end(tp.segment().begin(), tp.segment().end());
   }
+
+  for (int i = 0; i < tp.external_data_size(); i++) {
+    ret.external_data().push_back(std::make_pair(tp.external_data(i).key(), tp.external_data(i).value()));
+  }
+  if (tp.has_data_location()) {
+    ret.data_location() = tp.data_location();
+  }
   return ret;
 }
 
-void convertAttribute(const ONNX_NAMESPACE::AttributeProto& ap, Node* n, const int ir_version = IR_VERSION) {
+static void convertAttribute(const ONNX_NAMESPACE::AttributeProto& ap, Node* n, const int ir_version = IR_VERSION) {
   Symbol sym = Symbol(ap.name());
   switch (ap.type()) {
     case ONNX_NAMESPACE::AttributeProto_AttributeType_FLOAT:
@@ -153,7 +166,7 @@ void convertAttribute(const ONNX_NAMESPACE::AttributeProto& ap, Node* n, const i
       std::vector<Tensor> tensors;
       tensors.reserve(ap.tensors_size());
       for (int i = 0; i < ap.tensors_size(); i++) {
-        tensors.push_back(tensorProtoToTensor(ap.tensors(i)));
+        tensors.emplace_back(tensorProtoToTensor(ap.tensors(i)));
       }
       n->ts_(sym, std::move(tensors));
       break;
@@ -192,13 +205,13 @@ void convertAttribute(const ONNX_NAMESPACE::AttributeProto& ap, Node* n, const i
   }
 }
 
-void convertAttributes(ONNX_NAMESPACE::NodeProto& np, Node* n, const int ir_version = IR_VERSION) {
+static void convertAttributes(const ONNX_NAMESPACE::NodeProto& np, Node* n, const int ir_version = IR_VERSION) {
   for (int i = 0; i < np.attribute_size(); i++) {
     convertAttribute(np.attribute(i), n, ir_version);
   }
 }
 
-std::vector<Dimension> tensorShapeProtoToDimensions(const ONNX_NAMESPACE::TensorShapeProto& tsp) {
+static std::vector<Dimension> tensorShapeProtoToDimensions(const ONNX_NAMESPACE::TensorShapeProto& tsp) {
   std::vector<Dimension> dims;
   dims.reserve(tsp.dim_size());
   for (int i = 0; i < tsp.dim_size(); i++) {
@@ -215,8 +228,8 @@ std::vector<Dimension> tensorShapeProtoToDimensions(const ONNX_NAMESPACE::Tensor
   return dims;
 }
 
-void createDummyValue(
-    std::unique_ptr<Graph>& g,
+static void createDummyValue(
+    const std::unique_ptr<Graph>& g,
     const std::string& name,
     std::unordered_map<std::string, Value*>& value_by_name_of) {
   auto* undef = g->create(kCaptured, 1);
@@ -226,7 +239,7 @@ void createDummyValue(
 }
 
 std::unique_ptr<Graph> graphProtoToGraph(const ONNX_NAMESPACE::GraphProto& gp, bool nested, const int ir_version) {
-  std::unique_ptr<Graph> g(new Graph());
+  auto g = std::make_unique<Graph>();
 
   if (gp.has_name()) {
     g->setName(gp.name());
@@ -240,7 +253,7 @@ std::unique_ptr<Graph> graphProtoToGraph(const ONNX_NAMESPACE::GraphProto& gp, b
   // several stages.
   //
   // 1) add all input (to the graph) Values, owned by the sentinel Param node
-  // 2) add all Nodes and their output Values, but don't intialize inputs
+  // 2) add all Nodes and their output Values, but don't initialize inputs
   // 3) initialize inputs of all Nodes
   // 4) initialize inputs of the Return sentinel node
   // 5) fill in type info for graph outputs, and register them as outputs
@@ -300,7 +313,7 @@ std::unique_ptr<Graph> graphProtoToGraph(const ONNX_NAMESPACE::GraphProto& gp, b
   }
 
   for (int i = 0; i < gp.node_size(); i++) {
-    auto np = gp.node(i);
+    const auto& np = gp.node(i);
     auto* n = g->create(Symbol(np.op_type()), /* num_outputs = */ np.output_size());
     g->appendNode(n);
     for (int j = 0; j < np.output_size(); j++) {
@@ -390,7 +403,8 @@ std::unique_ptr<Graph> graphProtoToGraph(const ONNX_NAMESPACE::GraphProto& gp, b
 std::unique_ptr<Graph> ImportModelProto(const ModelProto& mp) {
   if (!mp.has_ir_version()) {
     return nullptr;
-  } else if (mp.ir_version() <= 1) {
+  }
+  if (mp.ir_version() <= 1) {
     // ir_version=1 is not supported and ir_version=0 is illegal
     return nullptr;
   }
@@ -405,13 +419,13 @@ std::unique_ptr<Graph> ImportModelProto(const ModelProto& mp) {
 }
 
 // Part 2: convert IR to ONNX Protobuf
-std::string value_name(Value* n) {
+static std::string value_name(const Value* n) {
   return n->uniqueName();
 }
 
-void encodeGraph(GraphProto* p_g, const std::shared_ptr<Graph>& g);
+static void encodeGraph(GraphProto* p_g, const std::shared_ptr<Graph>& g);
 
-void encodeTensor(ONNX_NAMESPACE::TensorProto* p, const Tensor& tensor) {
+static void encodeTensor(ONNX_NAMESPACE::TensorProto* p, const Tensor& tensor) {
   if (tensor.hasName()) {
     p->set_name(tensor.name());
   }
@@ -435,7 +449,14 @@ void encodeTensor(ONNX_NAMESPACE::TensorProto* p, const Tensor& tensor) {
     }
     case ONNX_NAMESPACE::TensorProto_DataType_FLOAT16:
     case ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FN:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT4E2M1:
     case ONNX_NAMESPACE::TensorProto_DataType_BOOL:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT4:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT4:
     case ONNX_NAMESPACE::TensorProto_DataType_INT8:
     case ONNX_NAMESPACE::TensorProto_DataType_INT16:
     case ONNX_NAMESPACE::TensorProto_DataType_INT32:
@@ -473,14 +494,26 @@ void encodeTensor(ONNX_NAMESPACE::TensorProto* p, const Tensor& tensor) {
       break;
     }
     case ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED:
+      [[fallthrough]];
+    default:
       fail_convert("Unknown tensor data type");
   }
   if (tensor.is_raw_data()) {
     p->set_raw_data(tensor.raw());
   }
+  if (!tensor.external_data().empty()) {
+    for (const auto& entry : tensor.external_data()) {
+      auto* external_data = p->add_external_data();
+      external_data->set_key(entry.first);
+      external_data->set_value(entry.second);
+    }
+  }
+  if (tensor.has_data_location()) {
+    p->set_data_location(tensor.data_location());
+  }
 }
 
-void addAttribute(ONNX_NAMESPACE::NodeProto* n_p, Node* n, Symbol name) {
+static void addAttribute(ONNX_NAMESPACE::NodeProto* n_p, Node* n, Symbol name) {
   auto attr = n_p->add_attribute();
   attr->set_name(name.toString());
   switch (n->kindOf(name)) {
@@ -550,7 +583,7 @@ void addAttribute(ONNX_NAMESPACE::NodeProto* n_p, Node* n, Symbol name) {
   }
 }
 
-void encodeTypeProtoTensorType(ONNX_NAMESPACE::TypeProto_Tensor* tensor_type, Value* n) {
+static void encodeTypeProtoTensorType(ONNX_NAMESPACE::TypeProto_Tensor* tensor_type, const Value* n) {
   if (n->elemType() != 0) {
     tensor_type->set_elem_type(n->elemType());
   }
@@ -569,7 +602,7 @@ void encodeTypeProtoTensorType(ONNX_NAMESPACE::TypeProto_Tensor* tensor_type, Va
   }
 }
 
-void encodeValueInfo(ONNX_NAMESPACE::ValueInfoProto* v, Value* n) {
+static void encodeValueInfo(ONNX_NAMESPACE::ValueInfoProto* v, Value* n) {
   v->set_name(value_name(n));
   if (n->elemType() != 0 || n->has_sizes()) {
     ONNX_NAMESPACE::TypeProto* t = v->mutable_type();
@@ -579,7 +612,7 @@ void encodeValueInfo(ONNX_NAMESPACE::ValueInfoProto* v, Value* n) {
 }
 
 void encodeGraph(GraphProto* p_g, const std::shared_ptr<Graph>& g) {
-  ONNX_ASSERT(p_g != nullptr);
+  ONNX_ASSERT(p_g != nullptr)
 
   if (g->has_name()) {
     p_g->set_name(g->name());
@@ -715,7 +748,7 @@ void assertNonNull(const std::shared_ptr<Graph>& g) {
   ONNX_ASSERTM(
       g.get() != nullptr,
       "Warning: onnx version converter is unable to parse input model. "
-      "(The IR version of the ONNX model may be too old.)");
+      "(The IR version of the ONNX model may be too old.)")
 }
 
 } // namespace ONNX_NAMESPACE

onnx/common/ir_pb_converter.h

@@ -13,7 +13,6 @@
 
 #include "onnx/common/common.h"
 #include "onnx/common/ir.h"
-#include "onnx/onnx_pb.h"
 
 namespace ONNX_NAMESPACE {
 

onnx/common/model_helpers.cc

@@ -4,10 +4,6 @@
 
 #include "onnx/common/model_helpers.h"
 
-#include "onnx/checker.h"
-#include "onnx/defs/schema.h"
-#include "onnx/string_utils.h"
-
 namespace ONNX_NAMESPACE {
 
 Common::Status BuildNode(
@@ -18,8 +14,9 @@ Common::Status BuildNode(
     std::vector<std::string> const& inputs,
     std::vector<std::string> const& outputs,
     NodeProto* node) {
-  if (node == NULL) {
-    return Common::Status(Common::CHECKER, Common::INVALID_ARGUMENT, "node_proto should not be nullptr.");
+  if (node == nullptr) {
+    return Common::Status(
+        Common::StatusCategory::CHECKER, Common::StatusCode::INVALID_ARGUMENT, "node_proto should not be nullptr.");
   }
   node->set_name(name);
   node->set_domain(domain);

onnx/common/model_helpers.h

@@ -8,7 +8,7 @@
 #include <vector>
 
 #include "onnx/common/status.h"
-#include "onnx/onnx-operators_pb.h"
+#include "onnx/onnx_pb.h"
 
 namespace ONNX_NAMESPACE {
 

onnx/common/path.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <string>
 #ifdef _WIN32
 // windows.h has preproc definitions for min and max, which prevents from using std::min and std::max.
 //  defining NOMINMAX disables the preproc macro.
@@ -15,50 +14,62 @@
 #endif
 #include <windows.h>
 
-#include <filesystem>
-
 #include "onnx/checker.h"
 #endif
 
 namespace ONNX_NAMESPACE {
 
 #ifdef _WIN32
-constexpr const char k_preferred_path_separator = '\\';
-#else // POSIX
-constexpr const char k_preferred_path_separator = '/';
-#endif
-
-#ifdef _WIN32
-inline std::wstring path_join(const std::wstring& origin, const std::wstring& append) {
-  return (std::filesystem::path(origin) / std::filesystem::path(append)).wstring();
-}
-inline std::wstring utf8str_to_wstring(const std::string& utf8str) {
-  if (utf8str.size() > INT_MAX) {
-    fail_check("utf8str_to_wstring: string is too long for converting to wstring.");
+inline std::wstring utf8str_to_wstring(const std::string& utf8str, bool try_decode = false) {
+  if (utf8str.empty()) {
+    return std::wstring();
+  }
+  auto size_required =
+      MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS | MB_PRECOMPOSED, utf8str.c_str(), -1, nullptr, 0);
+  if (size_required == 0) {
+    if (try_decode) {
+      return std::wstring(
+          reinterpret_cast<const wchar_t*>(utf8str.c_str()), utf8str.size() / sizeof(std::wstring::value_type));
+    }
+    auto last_error = GetLastError();
+    fail_check("MultiByteToWideChar in utf8str_to_wstring returned error:", last_error);
   }
-  int size_required = MultiByteToWideChar(CP_UTF8, 0, utf8str.c_str(), static_cast<int>(utf8str.size()), NULL, 0);
   std::wstring ws_str(size_required, 0);
-  MultiByteToWideChar(CP_UTF8, 0, utf8str.c_str(), static_cast<int>(utf8str.size()), &ws_str[0], size_required);
+  auto converted_size = MultiByteToWideChar(
+      CP_UTF8, MB_ERR_INVALID_CHARS | MB_PRECOMPOSED, utf8str.c_str(), -1, &ws_str[0], size_required);
+  if (converted_size == 0) {
+    auto last_error = GetLastError();
+    fail_check("MultiByteToWideChar in utf8str_to_wstring returned error:", last_error);
+  }
+  if (ws_str.back() == '\0') {
+    ws_str.pop_back();
+  }
   return ws_str;
 }
+
 inline std::string wstring_to_utf8str(const std::wstring& ws_str) {
-  if (ws_str.size() > INT_MAX) {
-    fail_check("wstring_to_utf8str: string is too long for converting to UTF-8.");
+  if (ws_str.empty()) {
+    return std::string();
+  }
+  auto size_required =
+      WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ws_str.c_str(), -1, nullptr, 0, nullptr, nullptr);
+  if (size_required == 0) {
+    auto last_error = GetLastError();
+    fail_check("WideCharToMultiByte in wstring_to_utf8str returned error:", last_error);
   }
-  int size_required =
-      WideCharToMultiByte(CP_UTF8, 0, ws_str.c_str(), static_cast<int>(ws_str.size()), NULL, 0, NULL, NULL);
   std::string utf8str(size_required, 0);
-  WideCharToMultiByte(
-      CP_UTF8, 0, ws_str.c_str(), static_cast<int>(ws_str.size()), &utf8str[0], size_required, NULL, NULL);
+  auto converted_size = WideCharToMultiByte(
+      CP_UTF8, WC_ERR_INVALID_CHARS, ws_str.c_str(), -1, &utf8str[0], size_required, nullptr, nullptr);
+  if (converted_size == 0) {
+    auto last_error = GetLastError();
+    fail_check("WideCharToMultiByte in wstring_to_utf8str returned error:", last_error);
+  }
+  if (utf8str.back() == '\0') {
+    utf8str.pop_back();
+  }
   return utf8str;
 }
 
-#else
-std::string path_join(const std::string& origin, const std::string& append);
-// TODO: also use std::filesystem::path for clean_relative_path after ONNX has supported C++17 for POSIX
-// Clean up relative path when there is ".." in the path, e.g.: a/b/../c -> a/c
-// It cannot work with absolute path
-std::string clean_relative_path(const std::string& path);
 #endif
 
 } // namespace ONNX_NAMESPACE

onnx/common/proto_util.h

@@ -26,17 +26,17 @@ using FunctionSpecId = std::string;
 // A single string representation of (domain, op, overload)
 using FunctionImplId = std::string;
 
-FunctionImplId GetFunctionImplId(const std::string& domain, const std::string& op, const std::string& overload) {
+inline FunctionImplId GetFunctionImplId(const std::string& domain, const std::string& op, const std::string& overload) {
   if (overload.empty())
     return NormalizeDomain(domain) + "::" + op;
   return NormalizeDomain(domain) + "::" + op + "::" + overload;
 }
 
-FunctionImplId GetFunctionImplId(const FunctionProto& function) {
+inline FunctionImplId GetFunctionImplId(const FunctionProto& function) {
   return GetFunctionImplId(function.domain(), function.name(), function.overload());
 }
 
-FunctionImplId GetCalleeId(const NodeProto& node) {
+inline FunctionImplId GetCalleeId(const NodeProto& node) {
   return GetFunctionImplId(node.domain(), node.op_type(), node.overload());
 }
 

onnx/common/status.cc

@@ -6,30 +6,31 @@
 
 #include "status.h"
 
-#include <assert.h>
+#include <cassert>
+#include <memory>
 
 #include "onnx/string_utils.h"
 
 namespace ONNX_NAMESPACE {
 namespace Common {
 
-Status::Status(StatusCategory category, int code, const std::string& msg) {
-  assert(static_cast<int>(StatusCode::OK) != code);
-  state_.reset(new State(category, code, msg));
+Status::Status(StatusCategory category, StatusCode code, const std::string& msg) {
+  assert(StatusCode::OK != code);
+  state_ = std::make_unique<State>(category, code, msg);
 }
 
-Status::Status(StatusCategory category, int code) : Status(category, code, EmptyString()) {}
+Status::Status(StatusCategory category, StatusCode code) : Status(category, code, EmptyString()) {}
 
 bool Status::IsOK() const noexcept {
-  return (state_ == NULL);
+  return (state_ == nullptr);
 }
 
 StatusCategory Status::Category() const noexcept {
   return IsOK() ? StatusCategory::NONE : state_->category;
 }
 
-int Status::Code() const noexcept {
-  return IsOK() ? static_cast<int>(StatusCode::OK) : state_->code;
+StatusCode Status::Code() const noexcept {
+  return IsOK() ? StatusCode::OK : state_->code;
 }
 
 const std::string& Status::ErrorMessage() const {
@@ -50,17 +51,17 @@ std::string Status::ToString() const {
   }
 
   result += " : ";
-  result += ONNX_NAMESPACE::to_string(Code());
+  result += ONNX_NAMESPACE::to_string(static_cast<int>(Code()));
   std::string msg;
 
-  switch (static_cast<StatusCode>(Code())) {
-    case INVALID_ARGUMENT:
+  switch (Code()) {
+    case StatusCode::INVALID_ARGUMENT:
       msg = "INVALID_ARGUMENT";
       break;
-    case INVALID_PROTOBUF:
+    case StatusCode::INVALID_PROTOBUF:
       msg = "INVALID_PROTOBUF";
       break;
-    case FAIL:
+    case StatusCode::FAIL:
       msg = "FAIL";
       break;
     default:

onnx/common/status.h

@@ -6,21 +6,24 @@
 
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 
+#include "onnx/onnx_pb.h"
+
 namespace ONNX_NAMESPACE {
 namespace Common {
 
-enum StatusCategory {
+enum class StatusCategory : std::uint8_t {
   NONE = 0,
   CHECKER = 1,
   OPTIMIZER = 2,
 };
 
-enum StatusCode {
+enum class StatusCode : std::uint8_t {
   OK = 0,
   FAIL = 1,
   INVALID_ARGUMENT = 2,
@@ -29,39 +32,40 @@ enum StatusCode {
 
 class Status {
  public:
-  Status() noexcept {}
+  Status() noexcept = default;
 
-  Status(StatusCategory category, int code, const std::string& msg);
+  Status(StatusCategory category, StatusCode code, const std::string& msg);
 
-  Status(StatusCategory category, int code);
+  Status(StatusCategory category, StatusCode code);
 
   Status(const Status& other) {
     *this = other;
   }
 
-  void operator=(const Status& other) {
+  Status& operator=(const Status& other) {
     if (&other != this) {
       if (nullptr == other.state_) {
         state_.reset();
       } else if (state_ != other.state_) {
-        state_.reset(new State(*other.state_));
+        state_ = std::make_unique<State>(*other.state_);
       }
     }
+    return *this;
   }
 
   Status(Status&&) = default;
   Status& operator=(Status&&) = default;
   ~Status() = default;
 
-  bool IsOK() const noexcept;
+  ONNX_API bool IsOK() const noexcept;
 
-  int Code() const noexcept;
+  ONNX_API StatusCode Code() const noexcept;
 
-  StatusCategory Category() const noexcept;
+  ONNX_API StatusCategory Category() const noexcept;
 
-  const std::string& ErrorMessage() const;
+  ONNX_API const std::string& ErrorMessage() const;
 
-  std::string ToString() const;
+  ONNX_API std::string ToString() const;
 
   bool operator==(const Status& other) const {
     return (this->state_ == other.state_) || (ToString() == other.ToString());
@@ -71,14 +75,15 @@ class Status {
     return !(*this == other);
   }
 
-  static const Status& OK() noexcept;
+  ONNX_API static const Status& OK() noexcept;
 
  private:
   struct State {
-    State(StatusCategory cat_, int code_, std::string msg_) : category(cat_), code(code_), msg(std::move(msg_)) {}
+    State(StatusCategory cat_, StatusCode code_, std::string msg_)
+        : category(cat_), code(code_), msg(std::move(msg_)) {}
 
     StatusCategory category = StatusCategory::NONE;
-    int code = 0;
+    StatusCode code{};
     std::string msg;
   };