onnx 1.13.1__cp37-cp37m-macosx_10_12_universal2.whl → 1.14.1__cp37-cp37m-macosx_10_12_universal2.whl

onnx/__init__.py

@@ -1,52 +1,88 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 # isort:skip_file
 import os
+import typing
+from typing import Union, IO, Optional, TypeVar, Any
 
-from .onnx_cpp2py_export import ONNX_ML  # noqa
+import google.protobuf.message
+
+from onnx.onnx_cpp2py_export import ONNX_ML
 from onnx.external_data_helper import (
     load_external_data_for_model,
     write_external_data_tensors,
     convert_model_to_external_data,
 )
-from .onnx_pb import *  # noqa
-from .onnx_operators_pb import *  # noqa
-from .onnx_data_pb import *  # noqa
-from .version import version as __version__  # noqa
+from onnx.onnx_pb import (
+    AttributeProto,
+    EXPERIMENTAL,
+    FunctionProto,
+    GraphProto,
+    IR_VERSION,
+    IR_VERSION_2017_10_10,
+    IR_VERSION_2017_10_30,
+    IR_VERSION_2017_11_3,
+    IR_VERSION_2019_1_22,
+    IR_VERSION_2019_3_18,
+    IR_VERSION_2019_9_19,
+    IR_VERSION_2020_5_8,
+    IR_VERSION_2021_7_30,
+    ModelProto,
+    NodeProto,
+    OperatorSetIdProto,
+    OperatorStatus,
+    STABLE,
+    SparseTensorProto,
+    StringStringEntryProto,
+    TensorAnnotation,
+    TensorProto,
+    TensorShapeProto,
+    TrainingInfoProto,
+    TypeProto,
+    ValueInfoProto,
+    Version,
+)
+from onnx.onnx_operators_pb import OperatorProto, OperatorSetProto
+from onnx.onnx_data_pb import MapProto, OptionalProto, SequenceProto
+from onnx.version import version as __version__
 
 # Import common subpackages so they're available when you 'import onnx'
-import onnx.checker  # noqa
-import onnx.defs  # noqa
-import onnx.helper  # noqa
-import onnx.utils  # noqa
-import onnx.compose  # noqa
-
-import google.protobuf.message
-
-from typing import Union, IO, Optional, cast, TypeVar, Any
+from onnx import (
+    checker,
+    compose,
+    defs,
+    gen_proto,
+    helper,
+    hub,
+    mapping,
+    numpy_helper,
+    parser,
+    printer,
+    shape_inference,
+    utils,
+    version_converter,
+)
 
 
-# f should be either readable or a file path
 def _load_bytes(f: Union[IO[bytes], str]) -> bytes:
-    if hasattr(f, "read") and callable(cast(IO[bytes], f).read):
-        s = cast(IO[bytes], f).read()
+    if hasattr(f, "read") and callable(typing.cast(IO[bytes], f).read):
+        content = typing.cast(IO[bytes], f).read()
     else:
-        with open(cast(str, f), "rb") as readable:
-            s = readable.read()
-    return s
+        with open(typing.cast(str, f), "rb") as readable:
+            content = readable.read()
+    return content
 
 
-# content should be bytes,
-# f should be either writable or a file path
 def _save_bytes(content: bytes, f: Union[IO[bytes], str]) -> None:
-    if hasattr(f, "write") and callable(cast(IO[bytes], f).write):
-        cast(IO[bytes], f).write(content)
+    if hasattr(f, "write") and callable(typing.cast(IO[bytes], f).write):
+        typing.cast(IO[bytes], f).write(content)
     else:
-        with open(cast(str, f), "wb") as writable:
+        with open(typing.cast(str, f), "wb") as writable:
             writable.write(content)
 
 
-# f should be either a readable file or a file path
 def _get_file_path(f: Union[IO[bytes], str]) -> Optional[str]:
     if isinstance(f, str):
         return os.path.abspath(f)
@@ -56,14 +92,13 @@ def _get_file_path(f: Union[IO[bytes], str]) -> Optional[str]:
 
 
 def _serialize(proto: Union[bytes, google.protobuf.message.Message]) -> bytes:
-    """
-    Serialize a in-memory proto to bytes
+    """Serialize a in-memory proto to bytes.
 
-    Arguments:
-        proto: a in-memory proto, such as a ModelProto, TensorProto, etc
+    Args:
+        proto: An in-memory proto, such as a ModelProto, TensorProto, etc
 
     Returns:
-        Serialized proto in bytes
+        Serialized proto in bytes.
     """
     if isinstance(proto, bytes):
         return proto
@@ -71,7 +106,7 @@ def _serialize(proto: Union[bytes, google.protobuf.message.Message]) -> bytes:
         try:
             result = proto.SerializeToString()
         except ValueError as e:
-            if proto.ByteSize() >= onnx.checker.MAXIMUM_PROTOBUF:
+            if proto.ByteSize() >= checker.MAXIMUM_PROTOBUF:
                 raise ValueError(
                     "The proto size is larger than the 2 GB limit. "
                     "Please use save_as_external_data to save tensors separately from the model file."
@@ -87,25 +122,25 @@ _Proto = TypeVar("_Proto", bound=google.protobuf.message.Message)
 
 
 def _deserialize(s: bytes, proto: _Proto) -> _Proto:
-    """
-    Parse bytes into a in-memory proto
+    """Parse bytes into a in-memory proto.
 
-    Arguments:
+    Args:
         s: bytes containing serialized proto
         proto: a in-memory proto object
 
     Returns:
-        The proto instance filled in by s
+        The proto instance filled in by `s`.
+
+    Raises:
+        TypeError: if `proto` is not a protobuf message.
     """
     if not isinstance(s, bytes):
-        raise ValueError(f"Parameter s must be bytes, but got type: {type(s)}")
+        raise TypeError(f"Parameter 's' must be bytes, but got type: {type(s)}")
 
     if not (hasattr(proto, "ParseFromString") and callable(proto.ParseFromString)):
-        raise ValueError(
-            f"No ParseFromString method is detected. Type is {type(proto)}"
-        )
+        raise TypeError(f"No ParseFromString method is detected. Type is {type(proto)}")
 
-    decoded = cast(Optional[int], proto.ParseFromString(s))
+    decoded = typing.cast(Optional[int], proto.ParseFromString(s))
     if decoded is not None and decoded != len(s):
         raise google.protobuf.message.DecodeError(
             f"Protobuf decoding consumed too few bytes: {decoded} out of {len(s)}"
@@ -115,20 +150,21 @@ def _deserialize(s: bytes, proto: _Proto) -> _Proto:
 
 def load_model(
     f: Union[IO[bytes], str],
-    format: Optional[Any] = None,
+    format: Optional[Any] = None,  # pylint: disable=redefined-builtin
     load_external_data: bool = True,
 ) -> ModelProto:
-    """
-    Loads a serialized ModelProto into memory
-    load_external_data is true if the external data under the same directory of the model and load the external data
-    If not, users need to call load_external_data_for_model with directory to load
+    """Loads a serialized ModelProto into memory.
 
-    Arguments:
+    Args:
         f: can be a file-like object (has "read" function) or a string containing a file name
         format: for future use
+        load_external_data: Whether to load the external data.
+            Set to True if the data is under the same directory of the model.
+            If not, users need to call :func:`load_external_data_for_model`
+            with directory to load external data from.
 
     Returns:
-        Loaded in-memory ModelProto
+        Loaded in-memory ModelProto.
     """
     s = _load_bytes(f)
     model = load_model_from_string(s, format=format)
@@ -142,53 +178,61 @@ def load_model(
     return model
 
 
-def load_tensor(f: Union[IO[bytes], str], format: Optional[Any] = None) -> TensorProto:
-    """
-    Loads a serialized TensorProto into memory
+def load_tensor(
+    f: Union[IO[bytes], str],
+    format: Optional[Any] = None,  # pylint: disable=redefined-builtin
+) -> TensorProto:
+    """Loads a serialized TensorProto into memory.
 
-    Arguments:
+    Args:
         f: can be a file-like object (has "read" function) or a string containing a file name
         format: for future use
 
     Returns:
-        Loaded in-memory TensorProto
+        Loaded in-memory TensorProto.
     """
     s = _load_bytes(f)
     return load_tensor_from_string(s, format=format)
 
 
-def load_model_from_string(s: bytes, format: Optional[Any] = None) -> ModelProto:
-    """
-    Loads a binary string (bytes) that contains serialized ModelProto
+def load_model_from_string(
+    s: bytes,
+    format: Optional[Any] = None,  # pylint: disable=redefined-builtin
+) -> ModelProto:
+    """Loads a binary string (bytes) that contains serialized ModelProto.
 
-    Arguments:
+    Args:
         s: a string, which contains serialized ModelProto
         format: for future use
 
     Returns:
-        Loaded in-memory ModelProto
+        Loaded in-memory ModelProto.
     """
+    del format  # Unused
     return _deserialize(s, ModelProto())
 
 
-def load_tensor_from_string(s: bytes, format: Optional[Any] = None) -> TensorProto:
-    """
-    Loads a binary string (bytes) that contains serialized TensorProto
+def load_tensor_from_string(
+    s: bytes,
+    format: Optional[Any] = None,  # pylint: disable=redefined-builtin
+) -> TensorProto:
+    """Loads a binary string (bytes) that contains serialized TensorProto.
 
-    Arguments:
+    Args:
         s: a string, which contains serialized TensorProto
         format: for future use
 
     Returns:
-        Loaded in-memory TensorProto
+        Loaded in-memory TensorProto.
     """
+    del format  # Unused
     return _deserialize(s, TensorProto())
 
 
 def save_model(
     proto: Union[ModelProto, bytes],
     f: Union[IO[bytes], str],
-    format: Optional[Any] = None,
+    format: Optional[Any] = None,  # pylint: disable=redefined-builtin
     save_as_external_data: bool = False,
     all_tensors_to_one_file: bool = True,
     location: Optional[str] = None,
@@ -198,7 +242,7 @@ def save_model(
     """
     Saves the ModelProto to the specified path and optionally, serialize tensors with raw data as external data before saving.
 
-    Arguments:
+    Args:
         proto: should be a in-memory ModelProto
         f: can be a file-like object (has "write" function) or a string containing a file name format for future use
         save_as_external_data: If true, save tensors to external file(s).
@@ -215,6 +259,8 @@ def save_model(
             If true, convert all tensors to external data
             If false, convert only non-attribute tensors to external data
     """
+    del format  # Unused
+
     if isinstance(proto, bytes):
         proto = _deserialize(proto, ModelProto())
 
@@ -228,21 +274,21 @@ def save_model(
         basepath = os.path.dirname(model_filepath)
         proto = write_external_data_tensors(proto, basepath)
 
-    s = _serialize(proto)
-    _save_bytes(s, f)
+    serialized = _serialize(proto)
+    _save_bytes(serialized, f)
 
 
 def save_tensor(proto: TensorProto, f: Union[IO[bytes], str]) -> None:
     """
     Saves the TensorProto to the specified path.
 
-    Arguments:
+    Args:
         proto: should be a in-memory TensorProto
         f: can be a file-like object (has "write" function) or a string containing a file name
         format: for future use
     """
-    s = _serialize(proto)
-    _save_bytes(s, f)
+    serialized = _serialize(proto)
+    _save_bytes(serialized, f)
 
 
 # For backward compatibility

onnx/backend/__init__.py

@@ -1 +1,3 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0

onnx/backend/base.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0613
 
@@ -124,6 +126,7 @@ class Backend:
             onnx.checker.check_node(node, special_context)
         else:
             onnx.checker.check_node(node)
+
         return None
 
     @classmethod

onnx/backend/sample/__init__.py

@@ -1 +1,3 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0

onnx/backend/sample/ops/__init__.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 import importlib
@@ -9,17 +11,17 @@ from typing import Dict
 
 
 def collect_sample_implementations() -> Dict[str, str]:
-    dict: Dict[str, str] = {}
-    _recursive_scan(sys.modules[__name__], dict)
-    return dict
+    dict_: Dict[str, str] = {}
+    _recursive_scan(sys.modules[__name__], dict_)
+    return dict_
 
 
-def _recursive_scan(package: ModuleType, dict: Dict[str, str]) -> None:
+def _recursive_scan(package: ModuleType, dict_: Dict[str, str]) -> None:
     pkg_dir = package.__path__  # type: ignore
     module_location = package.__name__
     for _module_loader, name, ispkg in pkgutil.iter_modules(pkg_dir):  # type: ignore
         module_name = f"{module_location}.{name}"  # Module/package
         module = importlib.import_module(module_name)
-        dict[name] = inspect.getsource(module)
+        dict_[name] = inspect.getsource(module)
         if ispkg:
-            _recursive_scan(module, dict)
+            _recursive_scan(module, dict_)

onnx/backend/sample/ops/abs.py

@@ -4,4 +4,4 @@ import numpy as np
 
 
 def abs(input: np.ndarray) -> np.ndarray:
-    return np.abs(input)
+    return np.abs(input)  # type: ignore[no-any-return]

onnx/backend/test/__init__.py

@@ -1,4 +1,7 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
+__all__ = ["BackendTest"]
 # for backward compatibility
-from .runner import Runner as BackendTest  # noqa
+from onnx.backend.test.runner import Runner as BackendTest

onnx/backend/test/case/__init__.py

@@ -1,10 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 import sys
 from typing import Dict, List, Tuple
 
-from .base import Snippets
-from .utils import import_recursive
+from onnx.backend.test.case.base import Snippets
+from onnx.backend.test.case.utils import import_recursive
 
 
 def collect_snippets() -> Dict[str, List[Tuple[str, str]]]:

onnx/backend/test/case/base.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 import inspect

onnx/backend/test/case/model/__init__.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 import sys
@@ -6,9 +8,8 @@ from typing import List, Optional, Sequence
 import numpy as np
 
 from onnx import ModelProto
-
-from ..test_case import TestCase
-from ..utils import import_recursive
+from onnx.backend.test.case.test_case import TestCase
+from onnx.backend.test.case.utils import import_recursive
 
 _SimpleModelTestCases = []
 
@@ -35,11 +36,12 @@ def expect(
     )
 
 
-BASE_URL = "https://download.onnxruntime.ai/onnx/models"
+# BASE_URL = "https://download.onnxruntime.ai/onnx/models"
+BASE_URL = "onnx/backend/test/data/light/light_%s.onnx"
 
 
 def collect_testcases() -> List[TestCase]:
-    """Collect model test cases defined in python/numpy code and in model zoo."""
+    """Collect model test cases defined in python/numpy code."""
 
     real_model_testcases = []
 
@@ -56,7 +58,7 @@ def collect_testcases() -> List[TestCase]:
     ]
 
     for test_name, model_name, rtol, atol in model_tests:
-        url = f"{BASE_URL}/{model_name}.tar.gz"
+        url = BASE_URL % model_name
         real_model_testcases.append(
             TestCase(
                 name=test_name,

onnx/backend/test/case/model/expand.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 from typing import Sequence
@@ -5,9 +7,8 @@ from typing import Sequence
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
 
 
 class ExpandDynamicShape(Base):

onnx/backend/test/case/model/gradient.py

@@ -1,13 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
 from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN, ONNX_DOMAIN
 
-from ..base import Base
-from . import expect
-
 
 class Gradient(Base):
     @staticmethod

onnx/backend/test/case/model/sequence.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 from __future__ import annotations
@@ -9,9 +11,8 @@ import numpy as np
 
 import onnx
 from onnx import TensorProto
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
 
 
 def SequenceEmptyImpl() -> List[Optional[np.ndarray]]:

onnx/backend/test/case/model/shrink.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
 
 
 class ShrinkTest(Base):

onnx/backend/test/case/model/sign.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
 
 
 class SingleSign(Base):

onnx/backend/test/case/model/single-relu.py

@@ -1,11 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
 
 
 class SingleRelu(Base):

onnx/backend/test/case/model/stringnormalizer.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 
 
@@ -6,9 +8,8 @@ from typing import Sequence
 import numpy as np
 
 import onnx
-
-from ..base import Base
-from . import expect
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
 
 
 class NormalizeStrings(Base):

onnx/backend/test/case/node/__init__.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 
 import sys
@@ -7,19 +9,18 @@ from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
 import numpy as np
 
 import onnx
+from onnx.backend.test.case.test_case import TestCase
+from onnx.backend.test.case.utils import import_recursive
 from onnx.onnx_pb import (
     AttributeProto,
     FunctionProto,
     GraphProto,
     ModelProto,
     NodeProto,
-    OperatorSetIdProto,
+    TensorProto,
     TypeProto,
 )
 
-from ..test_case import TestCase
-from ..utils import import_recursive
-
 _NodeTestCases = []
 _TargetOpType = None
 
@@ -131,7 +132,7 @@ def function_testcase_helper(
 ) -> Tuple[List[Tuple[List[NodeProto], Any]], int]:
     test_op = node.op_type
     op_prefix = test_op + "_" + name + "_expanded_function_"
-    schema = onnx.defs.get_schema(test_op, node.domain)
+    schema = onnx.defs.get_schema(test_op, domain=node.domain)
 
     # an op schema may have several functions, each for one opset version
     # opset versions include the op's since_version and other opset versions
@@ -182,6 +183,10 @@ def _extract_value_info(
             shape = None
             tensor_type_proto = onnx.helper.make_tensor_type_proto(elem_type, shape)
             type_proto = onnx.helper.make_sequence_type_proto(tensor_type_proto)
+        elif isinstance(input, TensorProto):
+            elem_type = input.data_type
+            shape = tuple(input.dims)
+            type_proto = onnx.helper.make_tensor_type_proto(elem_type, shape)
         else:
             elem_type = onnx.helper.np_dtype_to_tensor_dtype(input.dtype)
             shape = input.shape
@@ -230,8 +235,8 @@ def _make_test_model_gen_version(graph: GraphProto, **kwargs: Any) -> ModelProto
 # the latest opset vesion that supports before targeted opset version
 def expect(
     node_op: onnx.NodeProto,
-    inputs: Sequence[np.ndarray],
-    outputs: Sequence[np.ndarray],
+    inputs: Sequence[Union[np.ndarray, TensorProto]],
+    outputs: Sequence[Union[np.ndarray, TensorProto]],
     name: str,
     **kwargs: Any,
 ) -> None:
@@ -270,7 +275,7 @@ def expect(
         # To make sure the model will be produced with the same opset_version after opset changes
         # By default, it uses since_version as opset_version for produced models
         produce_opset_version = onnx.defs.get_schema(
-            node.op_type, node.domain
+            node.op_type, domain=node.domain
         ).since_version
         kwargs["opset_imports"] = [
             onnx.helper.make_operatorsetid(node.domain, produce_opset_version)
@@ -299,11 +304,12 @@ def expect(
     ) -> List[TypeProto]:
         if node_inputs:
             if node_inputs[0] != "":
-                return [present_value_info[0].type] + merge(
-                    node_inputs[1:], present_value_info[1:]
-                )
+                return [
+                    present_value_info[0].type,
+                    *merge(node_inputs[1:], present_value_info[1:]),
+                ]
             else:
-                return [TypeProto()] + merge(node_inputs[1:], present_value_info)
+                return [TypeProto(), *merge(node_inputs[1:], present_value_info)]
         return []
 
     merged_types = merge(list(node.input), inputs_vi)