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

onnx/checker.cc

@@ -4,18 +4,15 @@
 
 #include "onnx/checker.h"
 
-#include <fstream>
-#include <functional>
-#include <iterator>
-#include <set>
+#include <iostream>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 #include "onnx/common/file_utils.h"
+#include "onnx/common/path.h"
 #include "onnx/defs/schema.h"
 #include "onnx/defs/tensor_proto_util.h"
-#include "onnx/proto_utils.h"
 #include "onnx/shape_inference/implementation.h"
 #include "onnx/string_utils.h"
 
@@ -96,11 +93,11 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
 
   const char* value_field = nullptr;
 
-#define check_data_field(field)             \
-  bool has_##field = tensor.field().size(); \
-  if (has_##field) {                        \
-    ++num_value_fields;                     \
-    value_field = #field;                   \
+#define check_data_field(field)               \
+  bool has_##field = !tensor.field().empty(); \
+  if (has_##field) {                          \
+    ++num_value_fields;                       \
+    value_field = #field;                     \
   }
 
   check_data_field(float_data);
@@ -188,6 +185,7 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
       case TensorProto::FLOAT8E5M2FNUZ:
       case TensorProto::UINT4:
       case TensorProto::INT4:
+      case TensorProto::FLOAT4E2M1:
         check_field(int32_data);
         break;
 
@@ -313,10 +311,8 @@ void check_map(const MapProto& map, const CheckerContext& ctx) {
 // Check that the index data stored in a SparseTensorProto is valid.
 // indices: a 1-dimensional tensor; indices[i] represents the
 // linearized index value for the i-th nonzero value.
-void check_sparse_tensor_indices_1(
-    const TensorProto& indices,
-    const SparseTensorProto& sparse_tensor_proto,
-    size_t nnz) {
+static void
+check_sparse_tensor_indices_1(const TensorProto& indices, const SparseTensorProto& sparse_tensor_proto, size_t nnz) {
   int dense_rank = sparse_tensor_proto.dims_size();
   int64_t dense_size = 1;
   for (int i = 0; i < dense_rank; ++i)
@@ -353,10 +349,8 @@ void check_sparse_tensor_indices_1(
 // Check that the index data stored in a SparseTensorProto is valid.
 // indices: a 2-dimensional tensor; indices[i,j] represents the j-th
 // index value for the i-th nonzero value.
-void check_sparse_tensor_indices_2(
-    const TensorProto& indices,
-    const SparseTensorProto& sparse_tensor_proto,
-    size_t nnz) {
+static void
+check_sparse_tensor_indices_2(const TensorProto& indices, const SparseTensorProto& sparse_tensor_proto, size_t nnz) {
   int dense_rank = sparse_tensor_proto.dims_size();
   if (static_cast<size_t>(indices.dims(0)) != nnz) {
     fail_check("Sparse tensor indices (", indices.name(), ") first dimension size does not equal NNZ.");
@@ -517,7 +511,7 @@ void check_attribute(const AttributeProto& attr, const CheckerContext& ctx, cons
   for (const auto& sparse_tensor : attr.sparse_tensors()) {
     check_sparse_tensor(sparse_tensor, ctx);
   }
-  if (attr.graphs().size() > 0) {
+  if (!attr.graphs().empty()) {
     CheckerContext subgraph_ctx(ctx);
     subgraph_ctx.set_is_main_graph(false);
     for (const auto& graph : attr.graphs()) {
@@ -526,7 +520,7 @@ void check_attribute(const AttributeProto& attr, const CheckerContext& ctx, cons
   }
 }
 
-void print_warning_if_has_experimental(const std::unordered_set<std::string>& used_experimental_ops) {
+static void print_warning_if_has_experimental(const std::unordered_set<std::string>& used_experimental_ops) {
   if (!used_experimental_ops.empty()) {
     std::string all_experimental_ops;
     for (const auto& op : used_experimental_ops) {
@@ -534,7 +528,7 @@ void print_warning_if_has_experimental(const std::unordered_set<std::string>& us
     }
     // Remove the last comma which is unnecessary
     all_experimental_ops.pop_back();
-    std::cout << "Warning: Model contains experimental ops:" + all_experimental_ops << std::endl;
+    std::cout << "Warning: Model contains experimental ops:" + all_experimental_ops << '\n';
   }
 }
 
@@ -614,8 +608,7 @@ void check_graph(const GraphProto& graph, const CheckerContext& ctx, const Lexic
     lex_ctx.add(value_info.name());
   }
 
-  std::unordered_set<std::reference_wrapper<const std::string>, std::hash<std::string>, std::equal_to<std::string>>
-      initializer_name_checker;
+  std::unordered_set<std::string> initializer_name_checker;
 
   for (const auto& init : graph.initializer()) {
     enforce_has_field(init, name);
@@ -624,7 +617,7 @@ void check_graph(const GraphProto& graph, const CheckerContext& ctx, const Lexic
       fail_check("Tensor initializers must have a non-empty name");
     }
 
-    if (!initializer_name_checker.insert(std::cref(name)).second) {
+    if (!initializer_name_checker.emplace(name).second) {
       fail_check(name + " initializer name is not unique");
     }
 
@@ -649,7 +642,7 @@ void check_graph(const GraphProto& graph, const CheckerContext& ctx, const Lexic
     if (name.empty()) {
       fail_check("Sparse tensor initializers must have a non-empty name");
     }
-    if (!initializer_name_checker.insert(std::cref(name)).second) {
+    if (!initializer_name_checker.insert(name).second) {
       fail_check(name + " sparse initializer name is not unique across initializers and sparse_initializers");
     }
     check_sparse_tensor(sparse_init, ctx);
@@ -709,12 +702,20 @@ void check_graph(const GraphProto& graph, const CheckerContext& ctx, const Lexic
       lex_ctx.add(output);
     }
   }
+  for (const auto& value_info : graph.output()) {
+    if (!lex_ctx.this_graph_has(value_info.name())) {
+      fail_check("Graph output '", value_info.name(), "' is not an output of any node in graph.");
+    }
+  }
+
   print_warning_if_has_experimental(used_experimental_ops);
 }
 
 // Utilify function to get the imported version of domain from opset imports
 // Returns -1 if requested domain is not found in the opset_imports
-int get_version_for_domain(const std::string& domain, const std::unordered_map<std::string, int>& opset_imports) {
+static int get_version_for_domain(
+    const std::string& domain,
+    const std::unordered_map<std::string, int>& opset_imports) {
   auto it = opset_imports.find(domain);
   if (it == opset_imports.end()) {
     return -1;
@@ -888,7 +889,7 @@ void check_function(const FunctionProto& function, const CheckerContext& ctx, co
   print_warning_if_has_experimental(used_experimental_ops);
 }
 
-void check_model(const ModelProto& model, CheckerContext& ctx) {
+static void check_model(const ModelProto& model, CheckerContext& ctx) {
   if (!model.ir_version()) {
     fail_check("The model does not have an ir_version set properly.");
   }
@@ -904,7 +905,6 @@ void check_model(const ModelProto& model, CheckerContext& ctx) {
       }
     }
   }
-  std::unordered_map<std::string, int> versions;
   ctx.set_ir_version(static_cast<int>(model.ir_version()));
   std::unordered_map<std::string, int> opset_imports;
   for (const auto& opset_import : model.opset_import()) {
@@ -1038,7 +1038,7 @@ std::string resolve_external_data_location(
   struct stat buffer; // APPLE, wasm and non-glic stdlibs do not have stat64
   if (data_path.empty() || (data_path[0] != '#' && stat((data_path).c_str(), &buffer) != 0)) {
 #else
-  struct stat64 buffer; // All POSIX under glibc except APPLE and wasm have stat64
+  struct stat64 buffer{}; // All POSIX under glibc except APPLE and wasm have stat64
   if (data_path.empty() || (data_path[0] != '#' && stat64((data_path).c_str(), &buffer) != 0)) {
 #endif
     fail_check(
@@ -1061,7 +1061,7 @@ std::string resolve_external_data_location(
 #endif
 }
 
-std::set<std::string> experimental_ops = {
+static std::unordered_set<std::string> experimental_ops = {
     "ATen",
     "Affine",
     "ConstantFill",

onnx/checker.h

@@ -10,11 +10,8 @@
 #include <unordered_set>
 #include <utility>
 
-#include "onnx/defs/function.h"
 #include "onnx/defs/schema.h"
 #include "onnx/onnx-data_pb.h"
-#include "onnx/onnx-operators_pb.h"
-#include "onnx/onnx_pb.h"
 #include "onnx/string_utils.h"
 
 namespace ONNX_NAMESPACE {
@@ -92,10 +89,10 @@ class CheckerContext final {
     check_custom_domain_ = value;
   }
 
-  explicit CheckerContext() : ir_version_(-1) {}
+  explicit CheckerContext() = default;
 
  private:
-  int ir_version_;
+  int ir_version_{-1};
   std::unordered_map<std::string, int> opset_imports_;
   bool is_main_graph_ = true;
   const ISchemaRegistry* schema_registry_ = OpSchemaRegistry::Instance();
@@ -107,6 +104,7 @@ class CheckerContext final {
 class LexicalScopeContext final {
  public:
   LexicalScopeContext() = default;
+  ~LexicalScopeContext() = default;
 
   // Construct an instance with the lexical scope from the parent graph to allow
   // lookup of names from that scope via this_or_ancestor_graph_has.
@@ -116,16 +114,21 @@ class LexicalScopeContext final {
   // values from the parent scope so the values are copied instead.
   LexicalScopeContext(const LexicalScopeContext& parent_context) : parent_context_{&parent_context} {}
   LexicalScopeContext& operator=(const LexicalScopeContext& parent_context) {
+    if (this == &parent_context) {
+      return *this;
+    }
     parent_context_ = &parent_context;
     return *this;
   }
+  LexicalScopeContext(LexicalScopeContext&&) = delete;
+  LexicalScopeContext& operator=(LexicalScopeContext&&) = delete;
 
   void add(const std::string& name) {
     output_names.insert(name);
   }
 
   bool this_graph_has(const std::string& name) const {
-    return output_names.find(name) != output_names.cend();
+    return output_names.count(name) > 0;
   }
 
   bool this_or_ancestor_graph_has(const std::string& name) const {

onnx/checker.py

@@ -23,9 +23,7 @@ __all__ = [
 
 import os
 import sys
-from typing import Any, Callable, TypeVar
-
-from google.protobuf.message import Message
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
 
 import onnx.defs
 import onnx.onnx_cpp2py_export.checker as C  # noqa: N812
@@ -42,8 +40,11 @@ from onnx import (
     ValueInfoProto,
 )
 
-# Limitation of single protobuf file is 2GB
-MAXIMUM_PROTOBUF = 2000000000
+if TYPE_CHECKING:
+    from google.protobuf.message import Message
+
+# Limitation of single protobuf file is 2GiB
+MAXIMUM_PROTOBUF = 2147483648
 
 # TODO: This thing where we reserialize the protobuf back into the
 # string, only to deserialize it at the call site, is really goofy.
@@ -170,11 +171,11 @@ def check_model(
         protobuf_string = (
             model if isinstance(model, bytes) else model.SerializeToString()
         )
-        # If the protobuf is larger than 2GB,
+        # If the protobuf is larger than 2GiB,
         # remind users should use the model path to check
         if sys.getsizeof(protobuf_string) > MAXIMUM_PROTOBUF:
             raise ValueError(
-                "This protobuf of onnx model is too large (>2GB). Call check_model with model path instead."
+                "This protobuf of onnx model is too large (>2GiB). Call check_model with model path instead."
             )
         C.check_model(
             protobuf_string,

onnx/common/array_ref.h

@@ -23,9 +23,8 @@
 // removed a bunch of slice variants for simplicity...
 
 #pragma once
-#include <assert.h>
-
 #include <array>
+#include <cassert>
 #include <vector>
 
 namespace ONNX_NAMESPACE {
@@ -43,11 +42,11 @@ namespace ONNX_NAMESPACE {
 template <typename T>
 class ArrayRef {
  public:
-  typedef const T* iterator;
-  typedef const T* const_iterator;
-  typedef size_t size_type;
+  using iterator = const T*;
+  using const_iterator = const T*;
+  using size_type = size_t;
 
-  typedef std::reverse_iterator<iterator> reverse_iterator;
+  using reverse_iterator = std::reverse_iterator<iterator>;
 
  private:
   /// The start of the array, in an external buffer.
@@ -64,6 +63,7 @@ class ArrayRef {
   /*implicit*/ ArrayRef() : Data(nullptr), Length(0) {}
 
   /// Construct an ArrayRef from a single element.
+  /// NOLINTNEXTLINE(google-explicit-constructor)
   /*implicit*/ ArrayRef(const T& OneElt) : Data(&OneElt), Length(1) {}
 
   /// Construct an ArrayRef from a pointer and length.
@@ -74,14 +74,17 @@ class ArrayRef {
 
   /// Construct an ArrayRef from a std::vector.
   template <typename A>
+  /// NOLINTNEXTLINE(google-explicit-constructor)
   /*implicit*/ ArrayRef(const std::vector<T, A>& Vec) : Data(Vec.data()), Length(Vec.size()) {}
 
   /// Construct an ArrayRef from a std::array
   template <size_t N>
+  /// NOLINTNEXTLINE(google-explicit-constructor)
   /*implicit*/ constexpr ArrayRef(const std::array<T, N>& Arr) : Data(Arr.data()), Length(N) {}
 
   /// Construct an ArrayRef from a C array.
   template <size_t N>
+  /// NOLINTNEXTLINE(google-explicit-constructor, *array*)
   /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
 
   /// Construct an ArrayRef from a std::initializer_list.
@@ -170,14 +173,14 @@ class ArrayRef {
   /// The declaration here is extra complicated so that "arrayRef = {}"
   /// continues to select the move assignment operator.
   template <typename U>
-  typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type& operator=(U&& Temporary) = delete;
+  std::enable_if_t<std::is_same_v<U, T>, ArrayRef<T>>& operator=(U&& Temporary) = delete;
 
   /// Disallow accidental assignment from a temporary.
   ///
   /// The declaration here is extra complicated so that "arrayRef = {}"
   /// continues to select the move assignment operator.
   template <typename U>
-  typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type& operator=(std::initializer_list<U>) = delete;
+  std::enable_if_t<std::is_same_v<U, T>, ArrayRef<T>>& operator=(std::initializer_list<U>) = delete;
 
   /// @}
   /// @name Expensive Operations
@@ -189,6 +192,7 @@ class ArrayRef {
   /// @}
   /// @name Conversion operators
   /// @{
+  /// NOLINTNEXTLINE(google-explicit-constructor)
   operator std::vector<T>() const {
     return std::vector<T>(Data, Data + Length);
   }

onnx/common/assertions.h

@@ -51,6 +51,7 @@ std::string barf(const char* fmt, ...);
 
 // Note: msg must be a string literal
 #define _ONNX_ASSERTM(cond, msg, ...)                                                                \
+  /* NOLINTNEXTLINE */                                                                               \
   if (_ONNX_EXPECT(!(cond), 0)) {                                                                    \
     std::string error_msg = ::ONNX_NAMESPACE::barf(                                                  \
         "%s:%u: %s: Assertion `%s` failed: " msg, __FILE__, __LINE__, __func__, #cond, __VA_ARGS__); \

onnx/common/file_utils.h

@@ -10,14 +10,20 @@
 #include <fstream>
 #include <string>
 
-#include "onnx/checker.h"
+#ifdef _WIN32
 #include "onnx/common/path.h"
+#endif
+#include "onnx/checker.h"
 
 namespace ONNX_NAMESPACE {
 
 template <typename T>
-void LoadProtoFromPath(const std::string proto_path, T& proto) {
-  std::filesystem::path proto_u8_path = std::filesystem::u8path(proto_path);
+void LoadProtoFromPath(const std::string& proto_path, T& proto) {
+#ifdef _WIN32
+  std::filesystem::path proto_u8_path(utf8str_to_wstring(proto_path, true));
+#else
+  std::filesystem::path proto_u8_path(proto_path);
+#endif
   std::fstream proto_stream(proto_u8_path, std::ios::in | std::ios::binary);
   if (!proto_stream.good()) {
     fail_check("Unable to open proto file: ", proto_path, ". Please check if it is a valid proto. ");

onnx/common/interned_strings.cc

@@ -9,19 +9,17 @@
 
 #include "onnx/common/interned_strings.h"
 
-#include <stdint.h>
-
+#include <cstdint>
 #include <mutex>
 #include <string>
 #include <unordered_map>
-#include <vector>
 
 #include "onnx/common/assertions.h"
 
 namespace ONNX_NAMESPACE {
 
 struct InternedStrings {
-  InternedStrings() : next_sym(kLastSymbol) {
+  InternedStrings() {
 #define REGISTER_SYMBOL(s)   \
   string_to_sym_[#s] = k##s; \
   sym_to_string_[k##s] = #s;
@@ -63,7 +61,7 @@ struct InternedStrings {
   }
   std::unordered_map<std::string, uint32_t> string_to_sym_;
   std::unordered_map<uint32_t, std::string> sym_to_string_;
-  uint32_t next_sym;
+  uint32_t next_sym{kLastSymbol};
   std::mutex mutex_;
 };
 

onnx/common/interned_strings.h

@@ -8,11 +8,8 @@
 // Adventurous users should note that the APIs will probably change.
 
 #pragma once
-#include <stdint.h>
-
+#include <cstdint>
 #include <string>
-#include <unordered_map>
-#include <vector>
 
 namespace ONNX_NAMESPACE {
 
@@ -201,18 +198,20 @@ enum BuiltinSymbol {
 };
 
 struct Symbol {
-  Symbol() {}
+  Symbol() = default;
+  // NOLINTNEXTLINE(google-explicit-constructor)
   /*implicit*/ Symbol(BuiltinSymbol value) : value(value) {}
   explicit Symbol(const std::string& s);
   explicit Symbol(uint32_t value) : value(value) {}
 
+  // NOLINTNEXTLINE(google-explicit-constructor)
   operator uint32_t() const {
     return value;
   }
   const char* toString() const;
 
  private:
-  uint32_t value;
+  uint32_t value{0};
 };
 
 static inline bool operator==(Symbol lhs, Symbol rhs) {
@@ -226,7 +225,13 @@ static inline bool operator==(Symbol lhs, BuiltinSymbol rhs) {
   return static_cast<uint32_t>(lhs) == static_cast<uint32_t>(rhs);
 }
 
-inline Symbol operator"" _sym(const char* s, size_t) {
+inline Symbol
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 5
+operator"" _sym // gcc 4.8.5 insists on having a space (hard error).
+#else
+operator""_sym // clang 17 generates a deprecation warning if there is a space.
+#endif
+    (const char* s, size_t) {
   return Symbol(s);
 }