onnx 1.18.0__cp310-cp310-win32.whl → 1.19.1rc1__cp310-cp310-win32.whl

onnx/backend/test/data/node/test_sub_int8/test_data_set_0/output_0.pb

@@ -0,0 +1,8 @@
+B
zJ<
+
+	
+		
+
+
+
+

onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_0.pb

@@ -1 +1 @@
-B
xJ<
+B
xJ<

onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/output_0.pb

@@ -1,8 +1,5 @@
-B
zJ<
-
-	
-		
-
-
-
-
+B
zJ<
+
+
+
+

onnx/backend/test/data/node/test_swish/test_data_set_0/output_0.pb

@@ -0,0 +1 @@
+
B
yJ��6@Ae{@��@

onnx/backend/test/data/node/test_swish_expanded/test_data_set_0/output_0.pb

@@ -0,0 +1 @@
+
B
yJ��6@Ae{@��@

onnx/backend/test/data/node/test_tan/test_data_set_0/output_0.pb

@@ -1 +1 @@
-
B
yJ�
R������>�R�?=����JQ�f�����?-/�j%ԽF��>�>��A[�s?pm�=�u�>5z�>&PAzU����>s꒿��*?�D? �?��j��I�����̎;=]�A��T�A�0A��>�h�>�P��Q@@!���6k!>��4@��%@��оD����e޿
+
B
yJ�
R������>�R�?=����JQ�f�����?-/�k%ԽF��>��>��A[�s?pm�=�u�>5z�>&PAzU����>s꒿��*?�D?!�?��j��I�����̎;=]�A��T�A�0A��>�h�>�P��P@@!���6k!>��4@��%@��оD����e޿

onnx/backend/test/runner/__init__.py

@@ -111,7 +111,7 @@ class Runner:
         return self
 
     def enable_report(self) -> Runner:
-        import pytest
+        import pytest  # noqa: PLC0415
 
         for category, items_map in self._test_items.items():
             for item in items_map.values():
@@ -214,19 +214,16 @@ class Runner:
                         model_dir=model_dir,
                     )
             else:
-                if not np.issubdtype(ref_outputs[i].dtype, np.number):
-                    if ref_outputs[i].tolist() != outputs[i].tolist():
-                        raise AssertionError(f"{ref_outputs[i]} != {outputs[i]}")
-                    continue
-                np.testing.assert_equal(outputs[i].dtype, ref_outputs[i].dtype)
                 np.testing.assert_array_equal(
                     outputs[i].shape,
                     ref_outputs[i].shape,
                     err_msg=f"Output {i} has incorrect shape",
                 )
                 if ref_outputs[i].dtype == object:
+                    # Strings
                     np.testing.assert_array_equal(outputs[i], ref_outputs[i])
                 else:
+                    np.testing.assert_equal(outputs[i].dtype, ref_outputs[i].dtype)
                     np.testing.assert_allclose(
                         outputs[i], ref_outputs[i], rtol=rtol, atol=atol
                     )

onnx/checker.cc

@@ -4,25 +4,19 @@
 
 #include "onnx/checker.h"
 
-#include <iostream>
+#include <filesystem>
 #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/shape_inference/implementation.h"
 #include "onnx/string_utils.h"
 
 #ifdef _WIN32
-#include <direct.h>
-
-#include <filesystem>
-
-#else // POSIX
-#include <sys/stat.h>
+#include "onnx/common/path.h"
 #endif
 
 namespace ONNX_NAMESPACE {
@@ -183,6 +177,7 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
       case TensorProto::FLOAT8E4M3FNUZ:
       case TensorProto::FLOAT8E5M2:
       case TensorProto::FLOAT8E5M2FNUZ:
+      case TensorProto::FLOAT8E8M0:
       case TensorProto::UINT4:
       case TensorProto::INT4:
       case TensorProto::FLOAT4E2M1:
@@ -979,50 +974,29 @@ std::string resolve_external_data_location(
     const std::string& location,
     const std::string& tensor_name) {
 #ifdef _WIN32
-  auto file_path = std::filesystem::path(utf8str_to_wstring(location));
-  if (file_path.is_absolute()) {
-    fail_check(
-        "Location of external TensorProto ( tensor name: ",
-        tensor_name,
-        ") should be a relative path, but it is an absolute path: ",
-        location);
-  }
-  auto relative_path = file_path.lexically_normal().make_preferred().wstring();
-  // Check that normalized relative path contains ".." on Windows.
-  if (relative_path.find(L"..", 0) != std::string::npos) {
-    fail_check(
-        "Data of TensorProto ( tensor name: ",
-        tensor_name,
-        ") should be file inside the ",
-        base_dir,
-        ", but the '",
-        location,
-        "' points outside the directory");
-  }
-  std::wstring data_path = path_join(utf8str_to_wstring(base_dir), relative_path);
-  struct _stat64 buff;
-  if (data_path.empty() || (data_path[0] != '#' && _wstat64(data_path.c_str(), &buff) != 0)) {
-    fail_check(
-        "Data of TensorProto ( tensor name: ",
-        tensor_name,
-        ") should be stored in ",
-        location,
-        ", but it doesn't exist or is not accessible.");
-  }
-  return wstring_to_utf8str(data_path);
+  std::filesystem::path base_dir_path(utf8str_to_wstring(base_dir));
+  std::filesystem::path file_path(utf8str_to_wstring(location));
 #else // POSIX
-  if (location.empty()) {
+  std::filesystem::path base_dir_path(base_dir);
+  std::filesystem::path file_path(location);
+#endif
+  if (file_path.empty()) {
     fail_check("Location of external TensorProto ( tensor name: ", tensor_name, ") should not be empty.");
-  } else if (location[0] == '/') {
+  }
+  if (file_path.is_absolute()) {
     fail_check(
         "Location of external TensorProto ( tensor name: ",
         tensor_name,
         ") should be a relative path, but it is an absolute path: ",
         location);
   }
-  std::string relative_path = clean_relative_path(location);
-  // Check that normalized relative path contains ".." on POSIX
-  if (relative_path.find("..", 0) != std::string::npos) {
+  auto relative_path = file_path.lexically_normal().make_preferred();
+  // Check that normalized relative path doesn't contains ".."
+#ifdef _WIN32
+  if (relative_path.native().find(L"..", 0) != std::string::npos) {
+#else // POSIX
+  if (relative_path.native().find("..", 0) != std::string::npos) {
+#endif
     fail_check(
         "Data of TensorProto ( tensor name: ",
         tensor_name,
@@ -1032,33 +1006,31 @@ std::string resolve_external_data_location(
         location,
         "' points outside the directory");
   }
-  std::string data_path = path_join(base_dir, relative_path);
-  // use stat64 to check whether the file exists
-#if defined(__APPLE__) || defined(__wasm__) || !defined(__GLIBC__)
-  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)) {
+  auto data_path = base_dir_path / relative_path;
+#ifdef _WIN32
+  auto data_path_str = wstring_to_utf8str(data_path.native());
 #else
-  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)) {
+  auto data_path_str = data_path.native();
 #endif
+  // Check whether the file exists
+  if (data_path.empty() || (data_path_str[0] != '#' && !std::filesystem::exists(data_path))) {
     fail_check(
         "Data of TensorProto ( tensor name: ",
         tensor_name,
         ") should be stored in ",
-        data_path,
+        data_path_str,
         ", but it doesn't exist or is not accessible.");
   }
   // Do not allow symlinks or directories.
-  if (data_path.empty() || (data_path[0] != '#' && !S_ISREG(buffer.st_mode))) {
+  if (data_path.empty() || (data_path_str[0] != '#' && !std::filesystem::is_regular_file(data_path))) {
     fail_check(
         "Data of TensorProto ( tensor name: ",
         tensor_name,
         ") should be stored in ",
-        data_path,
+        data_path_str,
         ", but it is not regular file.");
   }
-  return data_path;
-#endif
+  return data_path_str;
 }
 
 static std::unordered_set<std::string> experimental_ops = {

onnx/checker.h

@@ -11,7 +11,7 @@
 #include <utility>
 
 #include "onnx/defs/schema.h"
-#include "onnx/onnx-data_pb.h"
+#include "onnx/onnx-data.pb.h"
 #include "onnx/string_utils.h"
 
 namespace ONNX_NAMESPACE {

onnx/checker.py

@@ -23,22 +23,11 @@ __all__ = [
 
 import os
 import sys
-from typing import TYPE_CHECKING, Any, Callable, TypeVar
+from typing import TYPE_CHECKING
 
 import onnx.defs
 import onnx.onnx_cpp2py_export.checker as C  # noqa: N812
-import onnx.shape_inference
-from onnx import (
-    IR_VERSION,
-    AttributeProto,
-    FunctionProto,
-    GraphProto,
-    ModelProto,
-    NodeProto,
-    SparseTensorProto,
-    TensorProto,
-    ValueInfoProto,
-)
+from onnx.onnx_pb import IR_VERSION
 
 if TYPE_CHECKING:
     from google.protobuf.message import Message
@@ -46,10 +35,6 @@ if TYPE_CHECKING:
 # 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.
-# Stop doing that.
-
 
 # NB: Please don't edit this context!
 DEFAULT_CONTEXT = C.CheckerContext()
@@ -60,9 +45,6 @@ DEFAULT_CONTEXT.opset_imports = {"": onnx.defs.onnx_opset_version()}
 LEXICAL_SCOPE_CONTEXT = C.LexicalScopeContext()
 
 
-FuncType = TypeVar("FuncType", bound=Callable[..., Any])
-
-
 def _ensure_proto_type(proto: Message, proto_type: type[Message]) -> None:
     if not isinstance(proto, proto_type):
         raise TypeError(
@@ -71,41 +53,43 @@ def _ensure_proto_type(proto: Message, proto_type: type[Message]) -> None:
 
 
 def check_value_info(
-    value_info: ValueInfoProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
+    value_info: onnx.ValueInfoProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
 ) -> None:
-    _ensure_proto_type(value_info, ValueInfoProto)
+    _ensure_proto_type(value_info, onnx.ValueInfoProto)
     return C.check_value_info(value_info.SerializeToString(), ctx)
 
 
-def check_tensor(tensor: TensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> None:
-    _ensure_proto_type(tensor, TensorProto)
+def check_tensor(
+    tensor: onnx.TensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
+) -> None:
+    _ensure_proto_type(tensor, onnx.TensorProto)
     return C.check_tensor(tensor.SerializeToString(), ctx)
 
 
 def check_attribute(
-    attr: AttributeProto,
+    attr: onnx.AttributeProto,
     ctx: C.CheckerContext = DEFAULT_CONTEXT,
     lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
 ) -> None:
-    _ensure_proto_type(attr, AttributeProto)
+    _ensure_proto_type(attr, onnx.AttributeProto)
     return C.check_attribute(attr.SerializeToString(), ctx, lexical_scope_ctx)
 
 
 def check_node(
-    node: NodeProto,
+    node: onnx.NodeProto,
     ctx: C.CheckerContext = DEFAULT_CONTEXT,
     lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
 ) -> None:
-    _ensure_proto_type(node, NodeProto)
+    _ensure_proto_type(node, onnx.NodeProto)
     return C.check_node(node.SerializeToString(), ctx, lexical_scope_ctx)
 
 
 def check_function(
-    function: FunctionProto,
+    function: onnx.FunctionProto,
     ctx: C.CheckerContext | None = None,
     lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
 ) -> None:
-    _ensure_proto_type(function, FunctionProto)
+    _ensure_proto_type(function, onnx.FunctionProto)
     if ctx is None:
         ctx = C.CheckerContext()
         ctx.ir_version = onnx.helper.find_min_ir_version_for(
@@ -119,23 +103,23 @@ def check_function(
 
 
 def check_graph(
-    graph: GraphProto,
+    graph: onnx.GraphProto,
     ctx: C.CheckerContext = DEFAULT_CONTEXT,
     lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
 ) -> None:
-    _ensure_proto_type(graph, GraphProto)
+    _ensure_proto_type(graph, onnx.GraphProto)
     return C.check_graph(graph.SerializeToString(), ctx, lexical_scope_ctx)
 
 
 def check_sparse_tensor(
-    sparse: SparseTensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
+    sparse: onnx.SparseTensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
 ) -> None:
-    _ensure_proto_type(sparse, SparseTensorProto)
+    _ensure_proto_type(sparse, onnx.SparseTensorProto)
     C.check_sparse_tensor(sparse.SerializeToString(), ctx)
 
 
 def check_model(
-    model: ModelProto | str | bytes | os.PathLike,
+    model: onnx.ModelProto | str | bytes | os.PathLike,
     full_check: bool = False,
     skip_opset_compatibility_check: bool = False,
     check_custom_domain: bool = False,

onnx/common/file_utils.h

@@ -29,6 +29,9 @@ void LoadProtoFromPath(const std::string& proto_path, T& proto) {
     fail_check("Unable to open proto file: ", proto_path, ". Please check if it is a valid proto. ");
   }
   std::string data{std::istreambuf_iterator<char>{proto_stream}, std::istreambuf_iterator<char>{}};
+  if (!proto_stream.good()) {
+    fail_check("Unable to read proto file: ", proto_path, ". Please check if it is a valid proto. ");
+  }
   if (!ParseProtoFromBytes(&proto, data.c_str(), data.size())) {
     fail_check(
         "Unable to parse proto from file: ", proto_path, ". Please check if it is a valid protobuf file of proto. ");

onnx/common/graph_node_list.h

@@ -59,7 +59,7 @@ struct generic_graph_node_list_iterator final {
     return cur;
   }
   generic_graph_node_list_iterator& operator++() {
-    ONNX_ASSERT(cur);
+    ONNX_ASSERT(cur)
     cur = cur->next_in_graph[d];
     return *this;
   }
@@ -69,7 +69,7 @@ struct generic_graph_node_list_iterator final {
     return old;
   }
   generic_graph_node_list_iterator& operator--() {
-    ONNX_ASSERT(cur);
+    ONNX_ASSERT(cur)
     cur = cur->next_in_graph[reverseDir()];
     return *this;
   }

onnx/common/interned_strings.cc

@@ -56,7 +56,7 @@ struct InternedStrings {
   const char* customString(Symbol sym) {
     std::lock_guard<std::mutex> guard(mutex_);
     auto it = sym_to_string_.find(sym);
-    ONNX_ASSERT(it != sym_to_string_.end());
+    ONNX_ASSERT(it != sym_to_string_.end())
     return it->second.c_str();
   }
   std::unordered_map<std::string, uint32_t> string_to_sym_;

onnx/common/interned_strings.h

@@ -190,7 +190,7 @@ namespace ONNX_NAMESPACE {
   _(block_size)                     \
   _(output_dtype)
 
-enum BuiltinSymbol {
+enum BuiltinSymbol : std::uint8_t {
 #define DEFINE_SYMBOL(s) k##s,
   FORALL_BUILTIN_SYMBOLS(DEFINE_SYMBOL)
 #undef DEFINE_SYMBOL