bigdl-core-npu 2.5.0__cp310-cp310-win_amd64.whl

intel_npu_acceleration_library/external/openvino/runtime/opset14/ops.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Factory functions for ops added to openvino opset14."""
+from functools import partial
+
+from typing import Union, Optional, List
+
+from openvino.runtime import Node, Type
+from openvino.runtime.opset_utils import _get_node_factory
+from openvino.runtime.utils.types import TensorShape
+from openvino.runtime.utils.decorators import nameable_op
+from openvino.runtime.utils.types import NodeInput, as_node, as_nodes
+
+_get_node_factory_opset14 = partial(_get_node_factory, "opset14")
+
+
+# -------------------------------------------- ops ------------------------------------------------
+
+@nameable_op
+def convert_promote_types(
+    left_node: NodeInput,
+    right_node: NodeInput,
+    promote_unsafe: bool = False,
+    pytorch_scalar_promotion: bool = False,
+    u64_integer_promotion_target: Union[str, Type] = "f32",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node performing conversion to common type based on promotion rules.
+
+    :param left_node: input node with type to be promoted to common one.
+    :param right_node: input node with type to be promoted to common one.
+    :param promote_unsafe: Bool attribute whether to allow promotions that might result in bit-widening, precision loss and undefined behaviors.
+    :param pytorch_scalar_promotion: Bool attribute whether to promote scalar input to type provided by non-scalar input when number format is matching.
+    :param u64_integer_promotion_target: Element type attribute to select promotion result when inputs are u64 and signed integer.
+    :param name: Optional name for the new output node.
+
+    :return: The new node performing ConvertPromoteTypes operation.
+    """
+    inputs = as_nodes(left_node, right_node, name=name)
+
+    attributes = {
+        "promote_unsafe": promote_unsafe,
+        "pytorch_scalar_promotion": pytorch_scalar_promotion,
+        "u64_integer_promotion_target": u64_integer_promotion_target,
+    }
+    return _get_node_factory_opset14().create("ConvertPromoteTypes", inputs, attributes)
+
+
+@nameable_op
+def inverse(
+    data: NodeInput,
+    adjoint: bool = False,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node with inverse matrices of the input.
+
+    :param data: Tensor with matrices to invert. Last two dimensions must be of the same size.
+    :param adjoint: Whether to return adjoint instead of inverse matrices. Defaults to false.
+    :param name: Optional name for the new output node.
+
+    :return: The new node performing Inverse operation.
+    """
+    inputs = as_nodes(data, name=name)
+
+    attributes = {
+        "adjoint": adjoint,
+    }
+
+    return _get_node_factory_opset14().create("Inverse", inputs, attributes)
+
+
+@nameable_op
+def max_pool(
+    data: NodeInput,
+    strides: List[int],
+    dilations: List[int],
+    pads_begin: List[int],
+    pads_end: List[int],
+    kernel_shape: TensorShape,
+    rounding_type: str = "floor",
+    auto_pad: Optional[str] = None,
+    index_element_type: Optional[Union[str, Type]] = "i64",
+    axis: Optional[int] = 0,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform max pooling operation and return both values and indices of the selected elements.
+
+    :param  data:                The node providing input data.
+    :param  strides:             The distance (in pixels) to slide the filter on the feature map
+                                 over the axes.
+    :param  dilations:           The dilation of filter elements(distance between elements).
+    :param  pads_begin:          The number of pixels to add at the beginning along each axis.
+    :param  pads_end:            The number of pixels to add at the end along each axis.
+    :param  kernel_shape:        The pooling operation kernel shape.
+    :param  rounding_type:       Determines used rounding schema when computing output shape.
+                                 Acceptable values are: ['floor', 'ceil', 'ceil_torch']. Defaults to 'floor'.
+    :param  auto_pad:            Determines how the padding is calculated. Acceptable values:
+                                 [None, 'same_upper', 'same_lower', 'valid']. Defaults to None.
+    :param  index_element_type:  The data type used for the indices output of this operator.
+                                 Defaults to i64.
+    :param  axis:                The first dimension in the data shape used to determine the maximum
+                                 returned index value. The value is the product of all dimensions
+                                 starting at the provided axis. Defaults to 0.
+    :param  name:                The optional name for the created output node.
+
+    :return:   The new node performing max pooling operation.
+    """
+    if auto_pad is None:
+        auto_pad = "explicit"
+    return _get_node_factory_opset14().create(
+        "MaxPool",
+        [as_node(data, name=name)],
+        {
+            "strides": strides,
+            "dilations": dilations,
+            "pads_begin": pads_begin,
+            "pads_end": pads_end,
+            "kernel": kernel_shape,
+            "rounding_type": rounding_type.upper(),
+            "auto_pad": auto_pad.upper(),
+            "index_element_type": index_element_type,
+            "axis": axis,
+        },
+    )
+
+
+@nameable_op
+def avg_pool(
+    data_batch: NodeInput,
+    strides: List[int],
+    pads_begin: TensorShape,
+    pads_end: TensorShape,
+    kernel_shape: TensorShape,
+    exclude_pad: bool,
+    rounding_type: str = "floor",
+    auto_pad: Optional[str] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Return average pooling node.
+
+    :param data_batch:      The input node providing data.
+    :param strides:         The window movement strides.
+    :param pads_begin:      The number of pixels to add at the beginning along each axis.
+    :param pads_end:        The number of pixels to add at the end along each axis.
+    :param kernel_shape:    The pooling window shape.
+    :param exclude_pad:     Whether or not to include zero padding in average computations.
+    :param rounding_type:   Determines used rounding schema when computing output shape. Acceptable
+                            values are: ['floor', 'ceil', 'ceil_torch']. Defaults to 'floor'.
+    :param auto_pad:        Determines how the padding is calculated. Acceptable values:
+                            [None, 'same_upper', 'same_lower', 'valid']. Defaults to None.
+    :param name:            Optional name for the new output node.
+
+    :return: New node with AvgPool operation applied on its data.
+    """
+    if auto_pad is None:
+        auto_pad = "explicit"
+    return _get_node_factory_opset14().create(
+        "AvgPool",
+        [as_node(data_batch, name=name)],
+        {
+            "strides": strides,
+            "pads_begin": pads_begin,
+            "pads_end": pads_end,
+            "kernel": kernel_shape,
+            "exclude-pad": exclude_pad,
+            "rounding_type": rounding_type.upper(),
+            "auto_pad": auto_pad.upper(),
+        },
+    )

intel_npu_acceleration_library/external/openvino/runtime/opset15/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Inlcudes new operators added in Opset15
+
+# TODO (ticket 138273): Add previous opset operators at the end of opset15 development
+from openvino.runtime.opset1.ops import parameter
+from openvino.runtime.opset15.ops import col2im
+from openvino.runtime.opset15.ops import scatter_nd_update

intel_npu_acceleration_library/external/openvino/runtime/opset15/ops.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Factory functions for ops added to openvino opset15."""
+from functools import partial
+from typing import Optional, Literal, List
+
+from openvino.runtime import Node, Type
+from openvino.runtime.opset_utils import _get_node_factory
+from openvino.runtime.utils.decorators import nameable_op
+from openvino.runtime.utils.types import NodeInput, as_nodes
+
+_get_node_factory_opset15 = partial(_get_node_factory, "opset15")
+
+# -------------------------------------------- ops ------------------------------------------------
+
+
+@nameable_op
+def scatter_nd_update(
+    data: NodeInput,
+    indices: NodeInput,
+    updates: NodeInput,
+    reduction: Optional[Literal["none", "sum", "sub", "prod", "min", "max"]] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs ScatterNDUpdate.
+
+    :param data: Node input representing the tensor to be updated.
+    :param indices: Node input representing the indices at which updates will be applied.
+    :param updates: Node input representing the updates to be applied.
+    :param reduction: The type of operation to perform on the inputs. One of "none", "sum",
+                      "sub", "prod", "min", "max".
+    :param name: Optional name for the output node.
+    :return: New node performing the ScatterNDUpdate.
+    """
+    inputs = as_nodes(data, indices, updates, name=name)
+    attributes = {}
+    if reduction:
+        attributes["reduction"] = reduction
+    return _get_node_factory_opset15().create("ScatterNDUpdate", inputs, attributes)
+
+
+@nameable_op
+def col2im(
+    data: NodeInput,
+    output_size: NodeInput,
+    kernel_size: NodeInput,
+    strides: Optional[List[int]] = None,
+    dilations: Optional[List[int]] = None,
+    pads_begin: Optional[List[int]] = None,
+    pads_end: Optional[List[int]] = None,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform data movement operation which combines sliding blocks into an image tensor.
+
+    :param  data:                The node providing input data.
+    :param  output_size:         Shape of the spatial dimensions of the output image.
+    :param  kernel_size:         Size of the sliding blocks.
+    :param  strides:             Stride on the sliding blocks in the input spatial dimensions. Defaults to [1, 1].
+    :param  dilations:           The dilation of filter elements (distance between elements). Defaults to [1, 1].
+    :param  pads_begin:          The number of pixels added at the beginning along each axis. Defaults to [0, 0].
+    :param  pads_end:            The number of pixels added at the end along each axis. Defaults to [0, 0].
+    :param  name:                The optional name for the created output node.
+
+    :return:   The new node performing Col2Im operation.
+    """
+    if strides is None:
+        strides = [1, 1]
+    if dilations is None:
+        dilations = [1, 1]
+    if pads_begin is None:
+        pads_begin = [0, 0]
+    if pads_end is None:
+        pads_end = [0, 0]
+    return _get_node_factory_opset15().create(
+        "Col2Im",
+        as_nodes(data, output_size, kernel_size, name=name),
+        {
+            "strides": strides,
+            "dilations": dilations,
+            "pads_begin": pads_begin,
+            "pads_end": pads_end,
+        },
+    )

intel_npu_acceleration_library/external/openvino/runtime/opset2/__init__.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from openvino.runtime.opset1.ops import absolute
+from openvino.runtime.opset1.ops import absolute as abs
+from openvino.runtime.opset1.ops import acos
+from openvino.runtime.opset1.ops import add
+from openvino.runtime.opset1.ops import asin
+from openvino.runtime.opset1.ops import atan
+from openvino.runtime.opset1.ops import avg_pool
+from openvino.runtime.opset1.ops import batch_norm_inference
+from openvino.runtime.opset2.ops import batch_to_space
+from openvino.runtime.opset1.ops import binary_convolution
+from openvino.runtime.opset1.ops import broadcast
+from openvino.runtime.opset1.ops import ceiling
+from openvino.runtime.opset1.ops import ceiling as ceil
+from openvino.runtime.opset1.ops import clamp
+from openvino.runtime.opset1.ops import concat
+from openvino.runtime.opset1.ops import constant
+from openvino.runtime.opset1.ops import convert
+from openvino.runtime.opset1.ops import convert_like
+from openvino.runtime.opset1.ops import convolution
+from openvino.runtime.opset1.ops import convolution_backprop_data
+from openvino.runtime.opset1.ops import cos
+from openvino.runtime.opset1.ops import cosh
+from openvino.runtime.opset1.ops import ctc_greedy_decoder
+from openvino.runtime.opset1.ops import deformable_convolution
+from openvino.runtime.opset1.ops import deformable_psroi_pooling
+from openvino.runtime.opset1.ops import depth_to_space
+from openvino.runtime.opset1.ops import detection_output
+from openvino.runtime.opset1.ops import divide
+from openvino.runtime.opset1.ops import elu
+from openvino.runtime.opset1.ops import equal
+from openvino.runtime.opset1.ops import erf
+from openvino.runtime.opset1.ops import exp
+from openvino.runtime.opset1.ops import fake_quantize
+from openvino.runtime.opset1.ops import floor
+from openvino.runtime.opset1.ops import floor_mod
+from openvino.runtime.opset1.ops import gather
+from openvino.runtime.opset1.ops import gather_tree
+from openvino.runtime.opset2.ops import gelu
+from openvino.runtime.opset1.ops import greater
+from openvino.runtime.opset1.ops import greater_equal
+from openvino.runtime.opset1.ops import grn
+from openvino.runtime.opset1.ops import group_convolution
+from openvino.runtime.opset1.ops import group_convolution_backprop_data
+from openvino.runtime.opset1.ops import hard_sigmoid
+from openvino.runtime.opset1.ops import interpolate
+from openvino.runtime.opset1.ops import less
+from openvino.runtime.opset1.ops import less_equal
+from openvino.runtime.opset1.ops import log
+from openvino.runtime.opset1.ops import logical_and
+from openvino.runtime.opset1.ops import logical_not
+from openvino.runtime.opset1.ops import logical_or
+from openvino.runtime.opset1.ops import logical_xor
+from openvino.runtime.opset1.ops import lrn
+from openvino.runtime.opset1.ops import lstm_cell
+from openvino.runtime.opset1.ops import lstm_sequence
+from openvino.runtime.opset1.ops import matmul
+from openvino.runtime.opset1.ops import max_pool
+from openvino.runtime.opset1.ops import maximum
+from openvino.runtime.opset1.ops import minimum
+from openvino.runtime.opset1.ops import mod
+from openvino.runtime.opset1.ops import multiply
+from openvino.runtime.opset2.ops import mvn
+from openvino.runtime.opset1.ops import negative
+from openvino.runtime.opset1.ops import non_max_suppression
+from openvino.runtime.opset1.ops import normalize_l2
+from openvino.runtime.opset1.ops import not_equal
+from openvino.runtime.opset1.ops import one_hot
+from openvino.runtime.opset1.ops import pad
+from openvino.runtime.opset1.ops import parameter
+from openvino.runtime.opset1.ops import power
+from openvino.runtime.opset1.ops import prelu
+from openvino.runtime.opset1.ops import prior_box
+from openvino.runtime.opset1.ops import prior_box_clustered
+from openvino.runtime.opset1.ops import psroi_pooling
+from openvino.runtime.opset1.ops import proposal
+from openvino.runtime.opset1.ops import range
+from openvino.runtime.opset1.ops import reduce_logical_and
+from openvino.runtime.opset1.ops import reduce_logical_or
+from openvino.runtime.opset1.ops import reduce_max
+from openvino.runtime.opset1.ops import reduce_mean
+from openvino.runtime.opset1.ops import reduce_min
+from openvino.runtime.opset1.ops import reduce_prod
+from openvino.runtime.opset1.ops import reduce_sum
+from openvino.runtime.opset1.ops import region_yolo
+from openvino.runtime.opset2.ops import reorg_yolo
+from openvino.runtime.opset1.ops import relu
+from openvino.runtime.opset1.ops import reshape
+from openvino.runtime.opset1.ops import result
+from openvino.runtime.opset1.ops import reverse_sequence
+from openvino.runtime.opset2.ops import roi_pooling
+from openvino.runtime.opset1.ops import select
+from openvino.runtime.opset1.ops import selu
+from openvino.runtime.opset1.ops import shape_of
+from openvino.runtime.opset1.ops import sigmoid
+from openvino.runtime.opset1.ops import sign
+from openvino.runtime.opset1.ops import sin
+from openvino.runtime.opset1.ops import sinh
+from openvino.runtime.opset1.ops import softmax
+from openvino.runtime.opset2.ops import space_to_batch
+from openvino.runtime.opset1.ops import space_to_depth
+from openvino.runtime.opset1.ops import split
+from openvino.runtime.opset1.ops import sqrt
+from openvino.runtime.opset1.ops import squared_difference
+from openvino.runtime.opset1.ops import squeeze
+from openvino.runtime.opset1.ops import strided_slice
+from openvino.runtime.opset1.ops import subtract
+from openvino.runtime.opset1.ops import tan
+from openvino.runtime.opset1.ops import tanh
+from openvino.runtime.opset1.ops import tensor_iterator
+from openvino.runtime.opset1.ops import tile
+from openvino.runtime.opset1.ops import topk
+from openvino.runtime.opset1.ops import transpose
+from openvino.runtime.opset1.ops import unsqueeze
+from openvino.runtime.opset1.ops import variadic_split

intel_npu_acceleration_library/external/openvino/runtime/opset2/ops.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Factory functions for all openvino ops."""
+from typing import Callable, Iterable, List, Optional, Set, Union
+
+import numpy as np
+from functools import partial
+import warnings
+
+from openvino.runtime import Node, Shape
+from openvino.runtime.op import Constant, Parameter
+from openvino.runtime.opset_utils import _get_node_factory
+from openvino.runtime.utils.decorators import binary_op, nameable_op, unary_op
+from openvino.runtime.utils.input_validation import (
+    assert_list_of_ints,
+    check_valid_attributes,
+    is_non_negative_value,
+    is_positive_value,
+)
+from openvino.runtime.utils.node_factory import NodeFactory
+from openvino.runtime.utils.types import (
+    NodeInput,
+    NumericData,
+    NumericType,
+    ScalarData,
+    TensorShape,
+    as_node,
+    as_nodes,
+    get_dtype,
+    get_element_type,
+    get_element_type_str,
+    make_constant_node,
+)
+
+_get_node_factory_opset2 = partial(_get_node_factory, "opset2")
+
+# -------------------------------------------- ops ------------------------------------------------
+
+
+@nameable_op
+def batch_to_space(
+    data: NodeInput,
+    block_shape: NodeInput,
+    crops_begin: NodeInput,
+    crops_end: NodeInput,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform BatchToSpace operation on the input tensor.
+
+    BatchToSpace permutes data from the batch dimension of the data tensor into spatial dimensions.
+
+    :param data: Node producing the data tensor.
+    :param block_shape: The sizes of the block of values to be moved.
+    :param crops_begin: Specifies the amount to crop from the beginning along each axis of `data`.
+    :param crops_end: Specifies the amount to crop from the end along each axis of `data`.
+    :param name: Optional output node name.
+    :return: The new node performing a BatchToSpace operation.
+    """
+    return _get_node_factory_opset2().create(
+        "BatchToSpace",
+        as_nodes(data, block_shape, crops_begin, crops_end, name=name),
+    )
+
+
+@unary_op
+def gelu(node: NodeInput, name: Optional[str] = None) -> Node:
+    r"""Perform Gaussian Error Linear Unit operation element-wise on data from input node.
+
+    Computes GELU function:
+
+    \f[ f(x) = 0.5\cdot x\cdot(1 + erf( \dfrac{x}{\sqrt{2}}) \f]
+
+    For more information refer to [Gaussian Error Linear Unit (GELU)](https://arxiv.org/pdf/1606.08415.pdf>)
+
+    :param node: Input tensor. One of: input node, array or scalar.
+    :param name: Optional output node name.
+    :return: The new node performing a GELU operation on its input data element-wise.
+    """
+    return _get_node_factory_opset2().create("Gelu", [node])
+
+
+@nameable_op
+def mvn(
+    data: Node,
+    across_channels: bool = False,
+    normalize_variance: bool = False,
+    eps: float = 1e-9,
+    name: Optional[str] = None,
+) -> Node:
+    r"""Perform Mean Variance Normalization operation on data from input node.
+
+    Computes MVN on the input tensor `data` (called `X`) using formula:
+
+    \f[ Y = \dfrac{X-EX}{\sqrt{E(X-EX)^2}} \f]
+
+    :param data: The node with data tensor.
+    :param across_channels: Denotes if mean values are shared across channels.
+    :param normalize_variance: Denotes whether to perform variance normalization.
+    :param eps: The number added to the variance to avoid division by zero
+                when normalizing the value. Scalar value.
+    :param name: Optional output node name.
+    :return: The new node performing a MVN operation on input tensor.
+    """
+    return _get_node_factory_opset2().create(
+        "MVN",
+        [data],
+        {
+            "across_channels": across_channels,
+            "normalize_variance": normalize_variance,
+            "eps": eps,
+        },
+    )
+
+
+@nameable_op
+def reorg_yolo(input: Node, stride: List[int], name: Optional[str] = None) -> Node:
+    """Return a node which produces the ReorgYolo operation.
+
+    :param input:   Input data.
+    :param stride:  Stride to reorganize input by.
+    :param name:    Optional name for output node.
+    :return: ReorgYolo node.
+    """
+    return _get_node_factory_opset2().create("ReorgYolo", [input], {"stride": stride})
+
+
+@nameable_op
+def roi_pooling(
+    input: NodeInput,
+    coords: NodeInput,
+    output_roi: Optional[TensorShape] = None,
+    spatial_scale: Optional[NumericData] = None,
+    method: str = "max",
+    name: Optional[str] = None,
+    *,
+    output_size: Optional[TensorShape] = None,
+) -> Node:
+    """Return a node which produces an ROIPooling operation.
+
+    :param input:          Input feature map `{N, C, ...}`.
+    :param coords:         Coordinates of bounding boxes.
+    :param output_roi:     Height/Width of ROI output features (shape).
+    :param spatial_scale:  Ratio of input feature map over input image size (float).
+    :param method:         Method of pooling - string: "max" or "bilinear". Default: "max"
+    :param output_size:    (DEPRECATED!) Height/Width of ROI output features (shape).
+                           Will override `output_roi` if used and change behavior of the operator.
+    :return:               ROIPooling node.
+    """
+    # Allow either one of these attributes to be passed.
+    if output_roi is None and output_size is None:
+        raise AttributeError("One of the following arguments must be defined: `output_roi`, `output_size`!")
+    # Force checking of spatial_scale.
+    if spatial_scale is None:
+        raise AttributeError("The following arguments must be defined: `spatial_scale`!")
+
+    def _deprecated_output_size_arg(output_roi: Optional[TensorShape], output_size: Optional[TensorShape]) -> Optional[TensorShape]:
+        if output_size is not None:
+            warnings.warn(
+                "`output_size` is deprecated and will be removed in future. "
+                "Value of `output_size` is going to override `output_roi` value and "
+                "`get_output_size` will behave like `get_output_roi` function."
+                "Please use only `output_roi` explicitly.",
+                DeprecationWarning,
+                stacklevel=3,
+            )
+            return output_size
+        return output_roi
+
+    method = method.lower()
+    roi_shape = _deprecated_output_size_arg(output_roi, output_size)
+    node = _get_node_factory_opset2().create(
+        "ROIPooling",
+        as_nodes(input, coords, name=name),
+        {
+            "output_size": Shape(roi_shape),
+            "output_roi": Shape(roi_shape),
+            "spatial_scale": spatial_scale,
+            "method": method,
+        },
+    )
+
+    # Override behavior when deprecated value was used.
+    if output_size is not None:
+        node.get_output_size = node.get_output_roi
+        node.set_output_size = node.set_output_roi
+
+    return node
+
+
+@nameable_op
+def space_to_batch(
+    data: NodeInput,
+    block_shape: NodeInput,
+    pads_begin: NodeInput,
+    pads_end: NodeInput,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform SpaceToBatch operation on the input tensor.
+
+    SpaceToBatch permutes data tensor blocks of spatial data into batch dimension.
+    The operator returns a copy of the input tensor where values from spatial blocks dimensions
+    are moved in the batch dimension
+
+    :param data: Node producing the data tensor.
+    :param block_shape: The sizes of the block of values to be moved.
+    :param pads_begin: Specifies the padding for the beginning along each axis of `data`.
+    :param pads_end: Specifies the padding for the ending along each axis of `data`.
+    :param name: Optional output node name.
+    :return: The new node performing a SpaceToBatch operation.
+    """
+    return _get_node_factory_opset2().create(
+        "SpaceToBatch",
+        as_nodes(data, block_shape, pads_begin, pads_end, name=name),
+    )