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

onnx/defs/tensor/utils.cc

@@ -11,6 +11,8 @@
 #include <utility>
 #include <vector>
 
+#include "onnx/defs/tensor_proto_util.h"
+
 namespace ONNX_NAMESPACE {
 void resizeShapeInferenceHelper(
     const TensorShapeProto& input_shape,
@@ -135,7 +137,7 @@ void resizeShapeInferenceHelper(
     if (input_shape.dim(i).has_dim_value()) {
       int64_t dim_value =
           static_cast<int64_t>(std::floor(static_cast<float>(input_shape.dim(i).dim_value()) * scales_data[i]));
-      // If output_shape has dim_value, we validate the caculated result
+      // If output_shape has dim_value, we validate the calculated result
       // If output_shape doesn's have one, we set it to the scaled result
       if (dim->has_dim_value()) {
         if (static_cast<int64_t>(dim->dim_value()) != dim_value) {
@@ -153,7 +155,7 @@ void resizeShapeInferenceHelper(
   }
 }
 
-void resizeShapeInferenceVersioned(InferenceContext& ctx, int opset_version) {
+static void resizeShapeInferenceVersioned(InferenceContext& ctx, int opset_version) {
   propagateElemTypeFromInputToOutput(ctx, 0, 0);
   if (!hasNInputShapes(ctx, 1)) {
     return;
@@ -334,7 +336,7 @@ void resizeShapeInferenceHelper_opset7_to_10(
     if (input_shape.dim(i).has_dim_value()) {
       int64_t dim_value =
           static_cast<int64_t>(std::floor(static_cast<float>(input_shape.dim(i).dim_value()) * scales_data[i]));
-      // If output_shape has dim_value, we validate the caculated result
+      // If output_shape has dim_value, we validate the calculated result
       // If output_shape doesn's have one, we set it to the scaled result
       if (dim->has_dim_value()) {
         if (static_cast<int64_t>(dim->dim_value()) != dim_value) {
@@ -379,7 +381,7 @@ void resizeShapeInference_opset7_to_10(InferenceContext& ctx) {
   if (nullptr != scales) {
     // Infer output shape's dimension value if 'scales' is known.
     if (scales->data_type() == TensorProto::FLOAT) {
-      const auto& scales_data = ParseData<float>(scales);
+      const auto scales_data = ParseData<float>(scales);
       if (scales_data.size() != static_cast<size_t>(input_shape.dim_size())) {
         fail_shape_inference("Number of elements of input 'scales' must be same as rank of input 'X'");
       }
@@ -393,8 +395,8 @@ void resizeShapeInference_opset7_to_10(InferenceContext& ctx) {
 std::function<void(OpSchema&)> PadDocGenerator(
     const char* description,
     const char* mode_description,
-    const std::vector<std::string> op_schema,
-    const std::string op_schema_description) {
+    const std::vector<std::string>& op_schema,
+    const std::string& op_schema_description) {
   return [=](OpSchema& schema) {
     schema.SetDoc(description);
     schema.Attr("mode", mode_description, AttributeProto::STRING, std::string("constant"));
@@ -464,7 +466,7 @@ std::function<void(OpSchema&)> PadDocGenerator(
         std::iota(axes.begin(), axes.end(), 0);
       }
 
-      int num_axes = axes.size();
+      auto num_axes = axes.size();
       auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
 
       // Populating default dims
@@ -482,8 +484,8 @@ std::function<void(OpSchema&)> PadDocGenerator(
           fail_shape_inference("'pads' input must be a 1D (shape: [2 * num_axes]) tensor of type int64");
         }
 
-        const auto& pads_data = ParseData<int64_t>(pads_initializer);
-        if (pads_data.size() != static_cast<size_t>(2 * num_axes)) {
+        const auto pads_data = ParseData<int64_t>(pads_initializer);
+        if (pads_data.size() != 2 * num_axes) {
           fail_shape_inference(
               "Pads has incorrect number of values. Expected 2 * ",
               num_axes,
@@ -500,7 +502,7 @@ std::function<void(OpSchema&)> PadDocGenerator(
           }
         }
 
-        for (int i = 0; i < num_axes; ++i) {
+        for (size_t i = 0; i < num_axes; ++i) {
           auto axis = axes[i];
           const auto& input_dim = input_shape.dim(axis);
           auto& out_dim = *out_dims[axis];

onnx/defs/tensor/utils.h

@@ -8,7 +8,6 @@
 #include <vector>
 
 #include "onnx/defs/schema.h"
-#include "onnx/defs/tensor_proto_util.h"
 
 namespace ONNX_NAMESPACE {
 // The below is called by ops after opset 11, inclusively.
@@ -37,7 +36,7 @@ void resizeShapeInferenceHelper_opset7_to_10(
     const std::vector<float>& scales_data,
     TensorShapeProto* output_shape);
 
-enum class KeepAspectRatioPolicy {
+enum class KeepAspectRatioPolicy : std::uint8_t {
   STRETCH,
   NOT_LARGER,
   NOT_SMALLER,
@@ -54,6 +53,6 @@ extern const char* NonZero_ver9_doc;
 std::function<void(OpSchema&)> PadDocGenerator(
     const char* description,
     const char* mode_description,
-    const std::vector<std::string> op_schema = OpSchema::all_tensor_types_ir4(),
-    const std::string op_schema_description = "Constrain input and output types to all tensor types.");
+    const std::vector<std::string>& op_schema = OpSchema::all_tensor_types_ir4(),
+    const std::string& op_schema_description = "Constrain input and output types to all tensor types.");
 } // namespace ONNX_NAMESPACE

onnx/defs/tensor_proto_util.cc

@@ -36,7 +36,7 @@ namespace ONNX_NAMESPACE {
 
 #define DEFINE_PARSE_DATA(type, typed_data_fetch, tensorproto_datatype)                                            \
   template <>                                                                                                      \
-  const std::vector<type> ParseData(const TensorProto* tensor_proto) {                                             \
+  std::vector<type> ParseData(const TensorProto* tensor_proto) {                                                   \
     if (!tensor_proto->has_data_type() || tensor_proto->data_type() == TensorProto_DataType_UNDEFINED) {           \
       fail_shape_inference("The type of tensor: ", tensor_proto->name(), " is undefined so it cannot be parsed."); \
     } else if (tensor_proto->data_type() != tensorproto_datatype) {                                                \
@@ -86,7 +86,7 @@ namespace ONNX_NAMESPACE {
       return res;                                                                                                  \
     }                                                                                                              \
     /* okay to remove const qualifier as we have already made a copy */                                            \
-    char* bytes = const_cast<char*>(raw_data.c_str());                                                             \
+    char* bytes = raw_data.data();                                                                                 \
     /* onnx is little endian serialized always-tweak byte order if needed */                                       \
     if (!is_processor_little_endian()) {                                                                           \
       const size_t element_size = sizeof(type);                                                                    \

onnx/defs/tensor_proto_util.h

@@ -6,17 +6,17 @@
 
 #include <vector>
 
-#include "onnx/onnx-operators_pb.h"
+#include "onnx/onnx_pb.h"
 
 namespace ONNX_NAMESPACE {
 
 template <typename T>
-TensorProto ToTensor(const T& value);
+ONNX_API TensorProto ToTensor(const T& value);
 
 template <typename T>
-TensorProto ToTensor(const std::vector<T>& values);
+ONNX_API TensorProto ToTensor(const std::vector<T>& values);
 
 template <typename T>
-const std::vector<T> ParseData(const TensorProto* tensor_proto);
+std::vector<T> ParseData(const TensorProto* tensor_proto);
 
 } // namespace ONNX_NAMESPACE

onnx/defs/tensor_util.cc

@@ -13,7 +13,7 @@ namespace ONNX_NAMESPACE {
 
 #define DEFINE_PARSE_DATA(type, typed_data_fetch)                          \
   template <>                                                              \
-  const std::vector<type> ParseData(const Tensor* tensor) {                \
+  std::vector<type> ParseData(const Tensor* tensor) {                      \
     std::vector<type> res;                                                 \
     if (!tensor->is_raw_data()) {                                          \
       const auto& data = tensor->typed_data_fetch();                       \
@@ -23,7 +23,7 @@ namespace ONNX_NAMESPACE {
     /* make copy as we may have to reverse bytes */                        \
     std::string raw_data = tensor->raw();                                  \
     /* okay to remove const qualifier as we have already made a copy */    \
-    char* bytes = const_cast<char*>(raw_data.c_str());                     \
+    char* bytes = raw_data.data();                                         \
     /*onnx is little endian serialized always-tweak byte order if needed*/ \
     if (!is_processor_little_endian()) {                                   \
       const size_t element_size = sizeof(type);                            \

onnx/defs/tensor_util.h

@@ -6,11 +6,11 @@
 
 #include <vector>
 
-#include "onnx/common/ir.h"
+#include "onnx/common/tensor.h"
 
 namespace ONNX_NAMESPACE {
 
 template <typename T>
-const std::vector<T> ParseData(const Tensor* tensor);
+std::vector<T> ParseData(const Tensor* tensor);
 
 } // namespace ONNX_NAMESPACE

onnx/defs/text/defs.cc

@@ -148,8 +148,9 @@ ONNX_OPERATOR_SET_SCHEMA(
         .Output(0, "Y", "UTF-8 Normalized strings", "tensor(string)")
         .Attr(
             std::string("case_change_action"),
-            std::string("string enum that cases output to be lowercased/uppercases/unchanged."
-                        " Valid values are \"LOWER\", \"UPPER\", \"NONE\". Default is \"NONE\""),
+            std::string(
+                "string enum that cases output to be lowercased/uppercases/unchanged."
+                " Valid values are \"LOWER\", \"UPPER\", \"NONE\". Default is \"NONE\""),
             AttributeProto::STRING,
             std::string("NONE"))
         .Attr(

onnx/defs/traditionalml/defs.cc

@@ -136,11 +136,11 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
             return;
           }
           auto& cast_to = cast_to_attr->s();
-          if (0 == cast_to.compare("TO_FLOAT")) {
+          if ("TO_FLOAT" == cast_to) {
             output_type->set_elem_type(TensorProto::FLOAT);
-          } else if (0 == cast_to.compare("TO_INT64")) {
+          } else if ("TO_INT64" == cast_to) {
             output_type->set_elem_type(TensorProto::INT64);
-          } else if (0 == cast_to.compare("TO_STRING")) {
+          } else if ("TO_STRING" == cast_to) {
             output_type->set_elem_type(TensorProto::STRING);
           }
         }));
@@ -194,8 +194,20 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
             AttributeProto::INT,
             static_cast<int64_t>(-1))
         .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
-          if (nullptr == ctx.getInputType(0))
+          auto* cats_int64s = ctx.getAttribute("cats_int64s");
+          if (cats_int64s == nullptr) {
+            fail_shape_inference("Attribute 'cats_int64s' is required.");
+          }
+          auto* cats_strings = ctx.getAttribute("cats_strings");
+          if (cats_strings == nullptr) {
+            fail_shape_inference("Attribute 'cats_strings' is required.");
+          }
+          if (cats_int64s->ints_size() != cats_strings->strings_size()) {
+            fail_shape_inference("Attributes 'cats_int64s' and 'cats_strings' are required to be the same length.");
+          }
+          if (nullptr == ctx.getInputType(0)) {
             return;
+          }
           auto input_elem_type = ctx.getInputType(0)->tensor_type().elem_type();
           if (TensorProto::STRING == input_elem_type) {
             updateOutputElemType(ctx, 0, TensorProto::INT64);
@@ -370,8 +382,7 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
             AttributeProto::TENSOR,
             OPTIONAL_VALUE)
         .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
-          int key_length, key_type;
-          std::tie(key_type, key_length) =
+          auto [key_type, key_length] =
               getAttributeElementTypeAndLength(ctx, {"keys_tensor", "keys_strings", "keys_int64s", "keys_floats"});
           if (key_type == TensorProto::UNDEFINED) {
             fail_shape_inference("At least one of keys_tensor, keys_strings, keys_int64s, keys_floats must be set.");
@@ -385,8 +396,7 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
                 " are different, which is not permitted for LabelEncoders.");
           }
 
-          int value_length, value_type;
-          std::tie(value_type, value_length) = getAttributeElementTypeAndLength(
+          auto [value_type, value_length] = getAttributeElementTypeAndLength(
               ctx, {"values_tensor", "values_strings", "values_int64s", "values_floats"});
           if (value_type == TensorProto::UNDEFINED) {
             fail_shape_inference(

onnx/defs/traditionalml/utils.h

@@ -1,9 +1,8 @@
-#include "onnx/defs/schema.h"
 #include "onnx/defs/shape_inference.h"
 
 namespace ONNX_NAMESPACE {
 
-void AssertAttributeProtoTypeAndLength(
+inline void AssertAttributeProtoTypeAndLength(
     const AttributeProto* attr_proto,
     int expected_length,
     TensorProto_DataType expected_type,

onnx/external_data_helper.py

@@ -8,7 +8,7 @@ import re
 import sys
 import uuid
 from itertools import chain
-from typing import Callable, Iterable
+from typing import TYPE_CHECKING, Callable
 
 import onnx.onnx_cpp2py_export.checker as c_checker
 from onnx.onnx_pb import (
@@ -19,6 +19,9 @@ from onnx.onnx_pb import (
     TensorProto,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
 
 class ExternalDataInfo:
     def __init__(self, tensor: TensorProto) -> None:
@@ -127,18 +130,24 @@ def convert_model_to_external_data(
             it will be converted to external data. To convert every tensor with raw data to external data set size_threshold=0.
         convert_attribute (bool): If true, convert all tensors to external data
                        If false, convert only non-attribute tensors to external data
+
+    Raise:
+        ValueError: If location is not a relative path.
+        FileExistsError: If a file already exists in location.
     """
     tensors = _get_initializer_tensors(model)
     if convert_attribute:
         tensors = _get_all_tensors(model)
 
     if all_tensors_to_one_file:
-        file_name = str(uuid.uuid1())
+        file_name = str(uuid.uuid1()) + ".data"
         if location:
             if os.path.isabs(location):
                 raise ValueError(
                     "location must be a relative path that is relative to the model path."
                 )
+            if os.path.exists(location):
+                raise FileExistsError(f"External data file exists in {location}.")
             file_name = location
         for tensor in tensors:
             if (
@@ -277,7 +286,7 @@ def _is_valid_filename(filename: str) -> bool:
 
 def uses_external_data(tensor: TensorProto) -> bool:
     """Returns true if the tensor stores data in an external location."""
-    return (  # type: ignore[no-any-return]
+    return (
         tensor.HasField("data_location")
         and tensor.data_location == TensorProto.EXTERNAL
     )

onnx/gen_proto.py

@@ -9,7 +9,10 @@ import os
 import re
 import subprocess
 from textwrap import dedent
-from typing import Iterable
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
 
 autogen_header = """\
 //
@@ -43,7 +46,7 @@ def process_ifs(lines: Iterable[str], onnx_ml: bool) -> Iterable[str]:
             assert in_if == 1
             in_if = 2
         elif ENDIF_ONNX_ML_REGEX.match(line):
-            assert in_if == 1 or in_if == 2  # noqa: PLR1714, PLR2004
+            assert in_if in (1, 2)
             in_if = 0
         else:  # noqa: PLR5501
             if in_if == 0:
@@ -119,7 +122,7 @@ def translate(source: str, proto: int, onnx_ml: bool, package_name: str) -> str:
         lines = convert_to_proto3(lines)
     else:
         assert proto == 2  # noqa: PLR2004
-    return "\n".join(lines)  # TODO: not Windows friendly
+    return os.linesep.join(lines)
 
 
 def qualify(f: str, pardir: str | None = None) -> str: