0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p\n"}}},{"rowIdx":2058,"cells":{"function_name":{"kind":"string","value":"reduce_logsumexp_v1"},"docstring":{"kind":"string","value":"Computes log(sum(exp(elements across dimensions of a tensor))).\n\nReduces `input_tensor` along the dimensions given in `axis`.\nUnless `keepdims` is true, the rank of the tensor is reduced by 1 for each\nentry in `axis`. If `keepdims` is true, the reduced dimensions\nare retained with length 1.\n\nIf `axis` has no entries, all dimensions are reduced, and a\ntensor with a single element is returned.\n\nThis function is more numerically stable than log(sum(exp(input))). It avoids\noverflows caused by taking the exp of large inputs and underflows caused by\ntaking the log of small inputs.\n\nFor example:\n\n```python\nx = tf.constant([[0., 0., 0.], [0., 0., 0.]])\ntf.reduce_logsumexp(x) # log(6)\ntf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\ntf.reduce_logsumexp(x, 1) # [log(3), log(3)]\ntf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\ntf.reduce_logsumexp(x, [0, 1]) # log(6)\n```\n\nArgs:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\nReturns:\n The reduced tensor."},"masked_code":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n# MASKED: reduce_logsumexp_v1 function (lines 2124-2175)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p"},"implementation":{"kind":"string","value":"@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)"},"start_line":{"kind":"number","value":2124,"string":"2,124"},"end_line":{"kind":"number","value":2175,"string":"2,175"},"file_content":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p\n"}}},{"rowIdx":2059,"cells":{"function_name":{"kind":"string","value":"reduce_logsumexp"},"docstring":{"kind":"string","value":"Computes log(sum(exp(elements across dimensions of a tensor))).\n\nReduces `input_tensor` along the dimensions given in `axis`.\nUnless `keepdims` is true, the rank of the tensor is reduced by 1 for each\nentry in `axis`. If `keepdims` is true, the reduced dimensions\nare retained with length 1.\n\nIf `axis` has no entries, all dimensions are reduced, and a\ntensor with a single element is returned.\n\nThis function is more numerically stable than log(sum(exp(input))). It avoids\noverflows caused by taking the exp of large inputs and underflows caused by\ntaking the log of small inputs.\n\nFor example:\n\n```python\nx = tf.constant([[0., 0., 0.], [0., 0., 0.]])\ntf.reduce_logsumexp(x) # log(6)\ntf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\ntf.reduce_logsumexp(x, 1) # [log(3), log(3)]\ntf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\ntf.reduce_logsumexp(x, [0, 1]) # log(6)\n```\n\nArgs:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\nReturns:\n The reduced tensor."},"masked_code":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n# MASKED: reduce_logsumexp function (lines 2178-2235)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p"},"implementation":{"kind":"string","value":"@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)"},"start_line":{"kind":"number","value":2178,"string":"2,178"},"end_line":{"kind":"number","value":2235,"string":"2,235"},"file_content":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p\n"}}},{"rowIdx":2060,"cells":{"function_name":{"kind":"string","value":"_as_indexed_slices"},"docstring":{"kind":"string","value":"Convert 'x' to IndexedSlices.\n\nConvert a dense Tensor to a block-sparse IndexedSlices.\n\nArgs:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\nReturns:\n An IndexedSlices object.\n\nRaises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object."},"masked_code":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\n# MASKED: _as_indexed_slices function (lines 2583-2604)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p"},"implementation":{"kind":"string","value":"def _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)"},"start_line":{"kind":"number","value":2583,"string":"2,583"},"end_line":{"kind":"number","value":2604,"string":"2,604"},"file_content":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p\n"}}},{"rowIdx":2061,"cells":{"function_name":{"kind":"string","value":"_as_indexed_slices_list"},"docstring":{"kind":"string","value":"Convert all elements of 'inputs' to IndexedSlices.\n\nAdditionally, homogenize the types of all the indices to\neither int32 or int64.\n\nArgs:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\nReturns:\n A list of IndexedSlices objects.\n\nRaises:\n TypeError: If 'inputs' is not a list or a tuple."},"masked_code":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\n# MASKED: _as_indexed_slices_list function (lines 2607-2639)\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p"},"implementation":{"kind":"string","value":"def _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs"},"start_line":{"kind":"number","value":2607,"string":"2,607"},"end_line":{"kind":"number","value":2639,"string":"2,639"},"file_content":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p\n"}}},{"rowIdx":2062,"cells":{"function_name":{"kind":"string","value":"add_n"},"docstring":{"kind":"string","value":"Adds all input tensors element-wise.\n\nConverts `IndexedSlices` objects into dense tensors prior to adding.\n\nArgs:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\nReturns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\nRaises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred."},"masked_code":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n# MASKED: add_n function (lines 2642-2677)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p"},"implementation":{"kind":"string","value":"@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)"},"start_line":{"kind":"number","value":2642,"string":"2,642"},"end_line":{"kind":"number","value":2677,"string":"2,677"},"file_content":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p\n"}}},{"rowIdx":2063,"cells":{"function_name":{"kind":"string","value":"accumulate_n"},"docstring":{"kind":"string","value":"Returns the element-wise sum of a list of tensors.\n\nOptionally, pass `shape` and `tensor_dtype` for shape and type checking,\notherwise, these are inferred.\n\n`tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\nwait for all of its inputs to be ready before beginning to sum. This can\nsave memory if inputs are ready at different times, since minimum temporary\nstorage is proportional to the output size rather than the inputs size.\n\n`accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\nFor example:\n\n```python\na = tf.constant([[1, 2], [3, 4]])\nb = tf.constant([[5, 0], [0, 6]])\ntf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n# Explicitly pass shape and type\ntf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n```\n\nArgs:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\nReturns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\nRaises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred."},"masked_code":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n# MASKED: accumulate_n function (lines 2680-2757)\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p"},"implementation":{"kind":"string","value":"@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access"},"start_line":{"kind":"number","value":2680,"string":"2,680"},"end_line":{"kind":"number","value":2757,"string":"2,757"},"file_content":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p\n"}}},{"rowIdx":2064,"cells":{"function_name":{"kind":"string","value":"reduced_shape"},"docstring":{"kind":"string","value":"Helper function for reduction ops.\n\nArgs:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\nReturns:\n A 1-D Tensor, the output shape as if keepdims were set to True."},"masked_code":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\n# MASKED: reduced_shape function (lines 3053-3084)\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p"},"implementation":{"kind":"string","value":"def reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]"},"start_line":{"kind":"number","value":3053,"string":"3,053"},"end_line":{"kind":"number","value":3084,"string":"3,084"},"file_content":{"kind":"string","value":"# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Basic arithmetic operators.\n\nSee the [python/math_ops](python/math_ops) guide.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.framework import common_shapes\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import graph_util\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import gen_data_flow_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import gen_nn_ops\nfrom tensorflow.python.ops import gen_sparse_ops\n# go/tf-wildcard-import\n# pylint: disable=wildcard-import\nfrom tensorflow.python.ops.gen_math_ops import *\n# pylint: enable=wildcard-import\nfrom tensorflow.python.platform import tf_logging as logging\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util import deprecation\nfrom tensorflow.python.util import dispatch\nfrom tensorflow.python.util import nest\nfrom tensorflow.python.util.tf_export import tf_export\n\n# Aliases for some automatically-generated names.\nlinspace = gen_math_ops.lin_space\nnextafter = gen_math_ops.next_after\n\narg_max = deprecation.deprecated(None, \"Use `tf.math.argmax` instead\")(arg_max) # pylint: disable=used-before-assignment\narg_min = deprecation.deprecated(None, \"Use `tf.math.argmin` instead\")(arg_min) # pylint: disable=used-before-assignment\ntf_export(v1=[\"arg_max\"])(arg_max)\ntf_export(v1=[\"arg_min\"])(arg_min)\n\n# This is set by resource_variable_ops.py. It is included in this way since\n# there is a circular dependency between math_ops and resource_variable_ops\n_resource_variable_type = None\n\n\ndef _set_doc(doc):\n\n def _decorator(func):\n func.__doc__ = doc\n return func\n\n return _decorator\n\n\n# pylint: disable=redefined-builtin\n@tf_export(v1=[\"math.argmax\", \"argmax\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_max.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmax(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmax_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmax\", \"argmax\", v1=[])\ndef argmax_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the largest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_max(input, axis, name=name, output_type=output_type)\n\n\n@tf_export(v1=[\"math.argmin\", \"argmin\"])\n@deprecation.deprecated_args(None, \"Use the `axis` argument instead\",\n \"dimension\")\n@_set_doc(\n gen_math_ops.arg_min.__doc__.replace(\"dimensions\", \"axes\").replace(\n \"dimension\", \"axis\"))\ndef argmin(input,\n axis=None,\n name=None,\n dimension=None,\n output_type=dtypes.int64):\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"dimension\", dimension)\n return argmin_v2(input, axis, output_type, name)\n\n\n@tf_export(\"math.argmin\", \"argmin\", v1=[])\ndef argmin_v2(input,\n axis=None,\n output_type=dtypes.int64,\n name=None):\n \"\"\"Returns the index with the smallest value across axes of a tensor.\n\n Note that in case of ties the identity of the return value is not guaranteed.\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`,\n `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`.\n axis: A `Tensor`. Must be one of the following types: `int32`, `int64`.\n int32 or int64, must be in the range `-rank(input), rank(input))`.\n Describes which axis of the input Tensor to reduce across. For vectors,\n use axis = 0.\n output_type: An optional `tf.DType` from: `tf.int32, tf.int64`.\n Defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `output_type`.\n \"\"\"\n if axis is None:\n axis = 0\n return gen_math_ops.arg_min(input, axis, name=name, output_type=output_type)\n\n\n# pylint: enable=redefined-builtin\n\n\n# pylint: disable=anomalous-backslash-in-string,protected-access\n# pylint: disable=g-docstring-has-escape\n@tf_export(\"math.abs\", \"abs\")\n@dispatch.add_dispatch_support\ndef abs(x, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the absolute value of a tensor.\n\n Given a tensor `x` of complex numbers, this operation returns a tensor of type\n `float32` or `float64` that is the absolute value of each element in `x`. All\n elements in `x` must be complex numbers of the form \\\\(a + bj\\\\). The\n absolute value is computed as \\\\( \\sqrt{a^2 + b^2}\\\\). For example:\n ```python\n x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])\n tf.abs(x) # [5.25594902, 6.60492229]\n ```\n\n Args:\n x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`,\n `int32`, `int64`, `complex64` or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` the same size and type as `x` with absolute\n values.\n Note, for `complex64` or `complex128` input, the returned `Tensor` will be\n of type `float32` or `float64`, respectively.\n \"\"\"\n with ops.name_scope(name, \"Abs\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex:\n return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)\n return gen_math_ops._abs(x, name=name)\n# pylint: enable=g-docstring-has-escape\n\n\n# pylint: disable=redefined-builtin\ndef _bucketize(input, boundaries, name=None):\n return gen_math_ops.bucketize(input=input, boundaries=boundaries, name=name)\n\n\n# pylint: enable=redefined-builtin\n\n\nclass DivideDelegateWithName(object):\n \"\"\"Use Python2/Python3 division delegation to implement divide for tensors.\"\"\"\n\n def __init__(self, x, name):\n \"\"\"Construct DivideDelegateWithName.\n\n Args:\n x: Tensor to use as left operand in operator overloads\n name: The name that is preferred for the op created.\n \"\"\"\n self.x = x\n self.name = name\n\n def __truediv__(self, y):\n return _truediv_python3(self.x, y, self.name)\n\n def __floordiv__(self, y):\n return floordiv(self.x, y, self.name)\n\n def __div__(self, y):\n return _div_python2(self.x, y, self.name)\n\n\n@tf_export(\"math.divide\", \"divide\")\n@dispatch.add_dispatch_support\ndef divide(x, y, name=None):\n \"\"\"Computes Python style division of `x` by `y`.\"\"\"\n\n if name is not None:\n # Cannot use tensors operator overload, because it has no way to track\n # override names. Use a dummy class to track the runtime division behavior\n return DivideDelegateWithName(x, name) / y\n else:\n return x / y\n\n\n@tf_export(\"math.multiply\", \"multiply\")\n@dispatch.add_dispatch_support\ndef multiply(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\nmultiply.__doc__ = gen_math_ops.mul.__doc__.replace(\"Multiply\", \"`tf.multiply`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.mul(x, y)` is deprecated, please use `tf.multiply(x, y)` or `x * y`\")\ndef _mul(x, y, name=None):\n return gen_math_ops.mul(x, y, name)\n\n\n_mul.__doc__ = (\n gen_math_ops.mul.__doc__ + (\"\" if _mul.__doc__ is None else _mul.__doc__))\n\n\n@tf_export(\"math.subtract\", \"subtract\")\n@dispatch.add_dispatch_support\ndef subtract(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\nsubtract.__doc__ = gen_math_ops.sub.__doc__.replace(\"`Sub`\", \"`tf.subtract`\")\n\n\n# TODO(aselle): put deprecation in after another round of global code changes\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`\")\ndef _sub(x, y, name=None):\n return gen_math_ops.sub(x, y, name)\n\n\n_sub.__doc__ = (\n gen_math_ops.sub.__doc__ + (\"\" if _sub.__doc__ is None else _sub.__doc__))\n\n\nnegative = gen_math_ops.neg\n\n\n# pylint: disable=g-docstring-has-escape\n@deprecation.deprecated(\n \"2016-12-30\",\n \"`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`\")\ndef _neg(x, name=None):\n \"\"\"Computes numerical negative value element-wise.\n\n I.e., \\\\(y = -x\\\\).\n\n Args:\n x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,\n `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.\n \"\"\"\n return negative(x, name)\n\n\n# pylint: enable=g-docstring-has-escape\n\n\n@tf_export(v1=[\"math.scalar_mul\", \"scalar_mul\"])\ndef scalar_mul(scalar, x, name=None):\n \"\"\"Multiplies a scalar times a `Tensor` or `IndexedSlices` object.\n\n Intended for use in gradient code which might deal with `IndexedSlices`\n objects, which are easy to multiply by a scalar but more expensive to\n multiply with arbitrary tensors.\n\n Args:\n scalar: A 0-D scalar `Tensor`. Must have known shape.\n x: A `Tensor` or `IndexedSlices` to be scaled.\n name: A name for the operation (optional).\n\n Returns:\n `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.\n\n Raises:\n ValueError: if scalar is not a 0-D `scalar`.\n \"\"\"\n scalar = ops.convert_to_tensor(\n scalar, dtype=x.dtype.base_dtype, name=\"scalar\")\n shape = scalar.get_shape()\n if shape.ndims == 0:\n if isinstance(x, ops.IndexedSlices):\n return ops.IndexedSlices(gen_math_ops.mul(scalar, x.values, name),\n x.indices, x.dense_shape)\n else:\n return gen_math_ops.mul(scalar, x, name)\n else:\n raise ValueError(\"Only scalar multiply works, got shape %s\" % shape)\n\n\n@tf_export(\"math.scalar_mul\", \"scalar_mul\", v1=[])\n@_set_doc(scalar_mul.__doc__)\ndef scalar_mul_v2(scalar, x, name=None):\n with ops.name_scope(name, \"scalar_mul\", [x]) as name:\n return scalar_mul(scalar, x, name)\n\n\n@tf_export(\"math.pow\", \"pow\")\n@dispatch.add_dispatch_support\ndef pow(x, y, name=None): # pylint: disable=redefined-builtin\n r\"\"\"Computes the power of one value to another.\n\n Given a tensor `x` and a tensor `y`, this operation computes \\\\(x^y\\\\) for\n corresponding elements in `x` and `y`. For example:\n\n ```python\n x = tf.constant([[2, 2], [3, 3]])\n y = tf.constant([[8, 16], [2, 3]])\n tf.pow(x, y) # [[256, 65536], [9, 27]]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`,\n `complex64`, or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`.\n \"\"\"\n with ops.name_scope(name, \"Pow\", [x]) as name:\n return gen_math_ops._pow(x, y, name=name)\n\n\n# pylint: disable=redefined-builtin,redefined-outer-name\n@tf_export(\"dtypes.complex\", \"complex\")\n@dispatch.add_dispatch_support\ndef complex(real, imag, name=None):\n r\"\"\"Converts two real numbers to a complex number.\n\n Given a tensor `real` representing the real part of a complex number, and a\n tensor `imag` representing the imaginary part of a complex number, this\n operation returns complex numbers elementwise of the form \\\\(a + bj\\\\), where\n *a* represents the `real` part and *b* represents the `imag` part.\n\n The input tensors `real` and `imag` must have the same shape.\n\n For example:\n\n ```python\n real = tf.constant([2.25, 3.25])\n imag = tf.constant([4.75, 5.75])\n tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]]\n ```\n\n Args:\n real: A `Tensor`. Must be one of the following types: `float32`,\n `float64`.\n imag: A `Tensor`. Must have the same type as `real`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `complex64` or `complex128`.\n \"\"\"\n real = ops.convert_to_tensor(real, name=\"real\")\n imag = ops.convert_to_tensor(imag, name=\"imag\")\n with ops.name_scope(name, \"Complex\", [real, imag]) as name:\n input_types = (real.dtype, imag.dtype)\n if input_types == (dtypes.float64, dtypes.float64):\n Tout = dtypes.complex128\n elif input_types == (dtypes.float32, dtypes.float32):\n Tout = dtypes.complex64\n else:\n raise TypeError(\"real and imag have incorrect types: \"\n \"{} {}\".format(real.dtype.name, imag.dtype.name))\n return gen_math_ops._complex(real, imag, Tout=Tout, name=name)\n\n\n@tf_export(\"math.real\", v1=[\"math.real\", \"real\"])\n@deprecation.deprecated_endpoints(\"real\")\n@dispatch.add_dispatch_support\ndef real(input, name=None):\n r\"\"\"Returns the real part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the real part of each element in `input` considered as a complex number.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.real(x) # [-2.25, 3.25]\n ```\n\n If `input` is already real, it is returned unchanged.\n\n Args:\n input: A `Tensor`. Must have numeric type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Real\", [input]) as name:\n if input.dtype.is_complex:\n real_dtype = input.dtype.real_dtype\n return gen_math_ops.real(input, Tout=real_dtype, name=name)\n else:\n return input\n\n\n@tf_export(\"math.imag\", v1=[\"math.imag\", \"imag\"])\n@deprecation.deprecated_endpoints(\"imag\")\n@dispatch.add_dispatch_support\ndef imag(input, name=None):\n r\"\"\"Returns the imaginary part of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the imaginary part of each element in `input` considered as a complex\n number. If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```python\n x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j])\n tf.imag(x) # [4.75, 5.75]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Imag\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n@tf_export(\"math.angle\", v1=[\"math.angle\", \"angle\"])\n@deprecation.deprecated_endpoints(\"angle\")\n@dispatch.add_dispatch_support\ndef angle(input, name=None):\n r\"\"\"Returns the element-wise argument of a complex (or real) tensor.\n\n Given a tensor `input`, this operation returns a tensor of type `float` that\n is the argument of each element in `input` considered as a complex number.\n\n The elements in `input` are considered to be complex numbers of the form\n \\\\(a + bj\\\\), where *a* is the real part and *b* is the imaginary part.\n If `input` is real then *b* is zero by definition.\n\n The argument returned by this function is of the form \\\\(atan2(b, a)\\\\).\n If `input` is real, a tensor of all zeros is returned.\n\n For example:\n\n ```\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.angle(input) ==> [2.0132, 1.056]\n ```\n\n Args:\n input: A `Tensor`. Must be one of the following types: `float`, `double`,\n `complex64`, `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `float32` or `float64`.\n \"\"\"\n with ops.name_scope(name, \"Angle\", [input]) as name:\n if input.dtype.is_complex:\n return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)\n else:\n return array_ops.zeros_like(input)\n\n\n# pylint: enable=redefined-outer-name,redefined-builtin\n\n\n@tf_export(\"math.round\", \"round\")\n@dispatch.add_dispatch_support\ndef round(x, name=None): # pylint: disable=redefined-builtin\n \"\"\"Rounds the values of a tensor to the nearest integer, element-wise.\n\n Rounds half to even. Also known as bankers rounding. If you want to round\n according to the current system rounding mode use tf::cint.\n For example:\n\n ```python\n x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])\n tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]\n ```\n\n Args:\n x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, or `int64`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as `x`.\n \"\"\"\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_integer:\n return x\n else:\n return gen_math_ops.round(x, name=name)\n\n\n@tf_export(\"dtypes.cast\", \"cast\")\n@dispatch.add_dispatch_support\ndef cast(x, dtype, name=None):\n \"\"\"Casts a tensor to a new type.\n\n The operation casts `x` (in case of `Tensor`) or `x.values`\n (in case of `SparseTensor` or `IndexedSlices`) to `dtype`.\n\n For example:\n\n ```python\n x = tf.constant([1.8, 2.2], dtype=tf.float32)\n tf.cast(x, tf.int32) # [1, 2], dtype=tf.int32\n ```\n\n The operation supports data types (for `x` and `dtype`) of\n `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`,\n `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`.\n In case of casting from complex types (`complex64`, `complex128`) to real\n types, only the real part of `x` is returned. In case of casting from real\n types to complex types (`complex64`, `complex128`), the imaginary part of the\n returned value is set to `0`. The handling of complex types here matches the\n behavior of numpy.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could\n be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`,\n `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`,\n `bfloat16`.\n dtype: The destination type. The list of supported dtypes is the same as\n `x`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and\n same type as `dtype`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `dtype`.\n \"\"\"\n base_type = dtypes.as_dtype(dtype).base_dtype\n if isinstance(x,\n (ops.Tensor, _resource_variable_type)) and base_type == x.dtype:\n return x\n with ops.name_scope(name, \"Cast\", [x]) as name:\n if isinstance(x, sparse_tensor.SparseTensor):\n values_cast = cast(x.values, base_type, name=name)\n x = sparse_tensor.SparseTensor(x.indices, values_cast, x.dense_shape)\n elif isinstance(x, ops.IndexedSlices):\n values_cast = cast(x.values, base_type, name=name)\n x = ops.IndexedSlices(values_cast, x.indices, x.dense_shape)\n else:\n # TODO(josh11b): If x is not already a Tensor, we could return\n # ops.convert_to_tensor(x, dtype=dtype, ...) here, but that\n # allows some conversions that cast() can't do, e.g. casting numbers to\n # strings.\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.base_dtype != base_type:\n x = gen_math_ops.cast(x, base_type, name=name)\n if x.dtype.is_complex and base_type.is_floating:\n logging.warn(\"Casting complex to real discards imaginary part.\")\n return x\n\n\n@tf_export(\"dtypes.saturate_cast\", \"saturate_cast\")\n@dispatch.add_dispatch_support\ndef saturate_cast(value, dtype, name=None):\n \"\"\"Performs a safe saturating cast of `value` to `dtype`.\n\n This function casts the input to `dtype` without applying any scaling. If\n there is a danger that values would over or underflow in the cast, this op\n applies the appropriate clamping before the cast.\n\n Args:\n value: A `Tensor`.\n dtype: The desired output `DType`.\n name: A name for the operation (optional).\n\n Returns:\n `value` safely cast to `dtype`.\n \"\"\"\n # When casting to a type with smaller representable range, clamp.\n # Note that this covers casting to unsigned types as well.\n with ops.name_scope(name, \"saturate_cast\", [value]) as name:\n value = ops.convert_to_tensor(value, name=\"value\")\n dtype = dtypes.as_dtype(dtype).base_dtype\n if value.dtype.min < dtype.min:\n value = gen_math_ops.maximum(value,\n ops.convert_to_tensor(\n dtype.min, dtype=value.dtype,\n name=\"min\"))\n if value.dtype.max > dtype.max:\n value = gen_math_ops.minimum(value,\n ops.convert_to_tensor(\n dtype.max, dtype=value.dtype,\n name=\"max\"))\n return cast(value, dtype, name=name)\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_float\"])\ndef to_float(x, name=\"ToFloat\"):\n \"\"\"Casts a tensor to type `float32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float32`.\n \"\"\"\n return cast(x, dtypes.float32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_double\"])\ndef to_double(x, name=\"ToDouble\"):\n \"\"\"Casts a tensor to type `float64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `float64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `float64`.\n \"\"\"\n return cast(x, dtypes.float64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int32\"])\ndef to_int32(x, name=\"ToInt32\"):\n \"\"\"Casts a tensor to type `int32`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int32`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int32`.\n \"\"\"\n return cast(x, dtypes.int32, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_int64\"])\ndef to_int64(x, name=\"ToInt64\"):\n \"\"\"Casts a tensor to type `int64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `int64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `int64`.\n \"\"\"\n return cast(x, dtypes.int64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_bfloat16\"])\ndef to_bfloat16(x, name=\"ToBFloat16\"):\n \"\"\"Casts a tensor to type `bfloat16`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `bfloat16`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `bfloat16`.\n \"\"\"\n return cast(x, dtypes.bfloat16, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex64\"])\ndef to_complex64(x, name=\"ToComplex64\"):\n \"\"\"Casts a tensor to type `complex64`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex64`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex64`.\n \"\"\"\n return cast(x, dtypes.complex64, name=name)\n\n\n@deprecation.deprecated(date=None, instructions=\"Use tf.cast instead.\")\n@tf_export(v1=[\"to_complex128\"])\ndef to_complex128(x, name=\"ToComplex128\"):\n \"\"\"Casts a tensor to type `complex128`.\n\n Args:\n x: A `Tensor` or `SparseTensor` or `IndexedSlices`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with\n type `complex128`.\n\n Raises:\n TypeError: If `x` cannot be cast to the `complex128`.\n \"\"\"\n return cast(x, dtypes.complex128, name=name)\n\n\nops.Tensor._override_operator(\"__neg__\", gen_math_ops.neg)\nops.Tensor._override_operator(\"__abs__\", abs)\n# __invert__ corresponds to the ~ operator. Here we follow the numpy convention\n# ~ marks an elementwise bit-wise inverse. This is only implemented for boolean\n# tensors and will throw a TypeError if used on nonboolean arrays\nops.Tensor._override_operator(\"__invert__\", gen_math_ops.logical_not)\n\n\ndef _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):\n \"\"\"Register operators with different tensor and scalar versions.\n\n If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,\n sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.\n\n Args:\n func: the operator\n op_name: name of the operator being overridden\n clazz_object: class to override for. Either `Tensor` or `SparseTensor`.\n \"\"\"\n\n def binary_op_wrapper(x, y):\n with ops.name_scope(None, op_name, [x, y]) as name:\n if isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor):\n return func(x, y, name=name)\n elif not isinstance(y, sparse_tensor.SparseTensor):\n try:\n y = ops.convert_to_tensor_v2(y, dtype_hint=x.dtype.base_dtype,\n name=\"y\")\n except TypeError:\n # If the RHS is not a tensor, it might be a tensor aware object\n # that can implement the operator with knowledge of itself\n # and the tensor.\n if hasattr(type(y), \"__r%s__\" % op_name):\n return NotImplemented\n else:\n raise\n return func(x, y, name=name)\n\n def binary_op_wrapper_sparse(sp_x, y):\n with ops.name_scope(None, op_name, [sp_x, y]) as name:\n y = ops.convert_to_tensor(y, dtype=sp_x.dtype.base_dtype, name=\"y\")\n return sparse_tensor.SparseTensor(sp_x.indices,\n func(\n sp_x.indices,\n sp_x.values,\n sp_x.dense_shape,\n y,\n name=name), sp_x.dense_shape)\n\n def r_binary_op_wrapper(y, x):\n with ops.name_scope(None, op_name, [x, y]) as name:\n x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name=\"x\")\n return func(x, y, name=name)\n\n # Propagate func.__doc__ to the wrappers\n try:\n doc = func.__doc__\n except AttributeError:\n doc = None\n binary_op_wrapper.__doc__ = doc\n r_binary_op_wrapper.__doc__ = doc\n binary_op_wrapper_sparse.__doc__ = doc\n\n if clazz_object is ops.Tensor:\n clazz_object._override_operator(\"__%s__\" % op_name, binary_op_wrapper)\n del binary_op_wrapper\n clazz_object._override_operator(\"__r%s__\" % op_name, r_binary_op_wrapper)\n del r_binary_op_wrapper\n else:\n clazz_object._override_operator(\"__%s__\" % op_name,\n binary_op_wrapper_sparse)\n del binary_op_wrapper_sparse\n\n\n# Conversion table for __truediv__. None entries mean no conversion required.\n_TRUEDIV_TABLE = {\n dtypes.uint8: dtypes.float32,\n dtypes.int8: dtypes.float32,\n dtypes.uint16: dtypes.float32,\n dtypes.int16: dtypes.float32,\n dtypes.int32: dtypes.float64,\n dtypes.int64: dtypes.float64,\n dtypes.bfloat16: None,\n dtypes.float16: None,\n dtypes.float32: None,\n dtypes.float64: None,\n dtypes.complex64: None,\n dtypes.complex128: None,\n}\n\n\n# NOTE: the support of \"sparse (true)div dense\" is currently not baked in into\n# \"tf.(true_)div()\". Until such an API decision is made, the supported usage is\n# to explicitly use the \"/\" operator to invoke either truediv or div.\ndef _sparse_dense_truediv(sp_indices, sp_values, sp_shape, y, name=None):\n \"\"\"Internal helper function for 'sp_t / dense_t'.\"\"\"\n with ops.name_scope(name, \"truediv\",\n [sp_indices, sp_values, sp_shape, y]) as name:\n sp_values = ops.convert_to_tensor(sp_values, name=\"sp_values\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = sp_values.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n sp_values = cast(sp_values, dtype)\n y = cast(y, dtype)\n return gen_sparse_ops.sparse_dense_cwise_div(\n sp_indices, sp_values, sp_shape, y, name=name)\n\n\ndef _truediv_python3(x, y, name=None):\n with ops.name_scope(name, \"truediv\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\")\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n try:\n dtype = _TRUEDIV_TABLE[x_dtype]\n except KeyError:\n raise TypeError(\"Invalid dtype %r in __truediv__\" % x_dtype)\n if dtype is not None:\n x = cast(x, dtype)\n y = cast(y, dtype)\n return gen_math_ops.real_div(x, y, name=name)\n\n\ndef _div_python2(x, y, name=None):\n \"\"\"Divide two values using Python 2 semantics. Used for Tensor.__div__.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n\n with ops.name_scope(name, \"div\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n if x_dtype.is_floating or x_dtype.is_complex:\n return gen_math_ops.real_div(x, y, name=name)\n else:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\n@tf_export(\"math.truediv\", \"truediv\")\n@dispatch.add_dispatch_support\ndef truediv(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 3 division operator semantics).\n\n NOTE: Prefer using the Tensor operator or tf.divide which obey Python\n division operator semantics.\n\n This function forces Python 3 division operator semantics where all integer\n arguments are cast to floating types first. This op is generated by normal\n `x / y` division in Python 3 and in Python 2.7 with\n `from __future__ import division`. If you want integer division that rounds\n down, use `x // y` or `tf.math.floordiv`.\n\n `x` and `y` must have the same numeric type. If the inputs are floating\n point, the output will have the same type. If the inputs are integral, the\n inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`\n and `int64` (matching the behavior of Numpy).\n\n Args:\n x: `Tensor` numerator of numeric type.\n y: `Tensor` denominator of numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` evaluated in floating point.\n\n Raises:\n TypeError: If `x` and `y` have different dtypes.\n \"\"\"\n return _truediv_python3(x, y, name)\n\n\n@deprecation.deprecated(\n date=None,\n instructions=\"Deprecated in favor of operator or tf.math.divide.\")\n@tf_export(v1=[\"div\"])\ndef div(x, y, name=None):\n \"\"\"Divides x / y elementwise (using Python 2 division operator semantics).\n\n NOTE: Prefer using the Tensor division operator or tf.divide which obey Python\n division operator semantics.\n\n This function divides `x` and `y`, forcing Python 2.7 semantics. That is,\n if one of `x` or `y` is a float, then the result will be a float.\n Otherwise, the output will be an integer type. Flooring semantics are used\n for integer division.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n Returns:\n `x / y` returns the quotient of x and y.\n \"\"\"\n return _div_python2(x, y, name)\n\n\n@tf_export(\"div_no_nan\")\n@dispatch.add_dispatch_support\ndef div_no_nan(x, y, name=None):\n \"\"\"Computes an unsafe divide which returns 0 if the y is zero.\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`.\n y: A `Tensor` whose dtype is compatible with `x`.\n name: A name for the operation (optional).\n Returns:\n The element-wise value of the x divided by y.\n \"\"\"\n\n with ops.name_scope(name, \"div_no_nan\", [x, y]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n y = ops.convert_to_tensor(y, name=\"y\", dtype=x.dtype.base_dtype)\n x_dtype = x.dtype.base_dtype\n y_dtype = y.dtype.base_dtype\n if x_dtype != y_dtype:\n raise TypeError(\"x and y must have the same dtype, got %r != %r\" %\n (x_dtype, y_dtype))\n return gen_math_ops.div_no_nan(x, y, name=name)\n\n\n# TODO(aselle): This should be removed\nmod = gen_math_ops.floor_mod\n\n\n# TODO(aselle): Deprecate this once all internal functionality uses\n# tf.truncatediv\n@tf_export(\"math.floordiv\", v1=[\"math.floordiv\", \"floordiv\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"floordiv\")\ndef floordiv(x, y, name=None):\n \"\"\"Divides `x / y` elementwise, rounding toward the most negative integer.\n\n The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for\n floating point arguments so that the result is always an integer (though\n possibly an integer represented as floating point). This op is generated by\n `x // y` floor division in Python 3 and in Python 2.7 with\n `from __future__ import division`.\n\n `x` and `y` must have the same type, and the result will have the same type\n as well.\n\n Args:\n x: `Tensor` numerator of real numeric type.\n y: `Tensor` denominator of real numeric type.\n name: A name for the operation (optional).\n\n Returns:\n `x / y` rounded down.\n\n Raises:\n TypeError: If the inputs are complex.\n \"\"\"\n with ops.name_scope(name, \"floordiv\", [x, y]) as name:\n return gen_math_ops.floor_div(x, y, name=name)\n\n\nrealdiv = gen_math_ops.real_div\ntruncatediv = gen_math_ops.truncate_div\n# TODO(aselle): Rename this to floordiv when we can.\nfloor_div = gen_math_ops.floor_div\ntruncatemod = gen_math_ops.truncate_mod\nfloormod = gen_math_ops.floor_mod\n\n\ndef _mul_dispatch(x, y, name=None):\n \"\"\"Dispatches cwise mul for \"Dense*Dense\" and \"Dense*Sparse\".\"\"\"\n is_tensor_y = isinstance(y, ops.Tensor)\n if is_tensor_y:\n return gen_math_ops.mul(x, y, name=name)\n else:\n assert isinstance(y, sparse_tensor.SparseTensor) # Case: Dense * Sparse.\n new_vals = gen_sparse_ops.sparse_dense_cwise_mul(y.indices, y.values,\n y.dense_shape, x, name)\n return sparse_tensor.SparseTensor(y.indices, new_vals, y.dense_shape)\n\n\n# NOTE(aselle): When integer division is added for sparse_dense_cwise,\n# div, truediv, and floordiv should be delegated appropriately for\n# Python sematnics, analogous to dense cwise tensor operations.\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_div, \"div\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(_sparse_dense_truediv, \"truediv\",\n sparse_tensor.SparseTensor)\n_OverrideBinaryOperatorHelper(gen_sparse_ops.sparse_dense_cwise_mul, \"mul\",\n sparse_tensor.SparseTensor)\n\n_OverrideBinaryOperatorHelper(gen_math_ops.add, \"add\")\n_OverrideBinaryOperatorHelper(gen_math_ops.sub, \"sub\")\n_OverrideBinaryOperatorHelper(_mul_dispatch, \"mul\")\n_OverrideBinaryOperatorHelper(_div_python2, \"div\")\n_OverrideBinaryOperatorHelper(_truediv_python3, \"truediv\")\n_OverrideBinaryOperatorHelper(floordiv, \"floordiv\")\n_OverrideBinaryOperatorHelper(gen_math_ops.floor_mod, \"mod\")\n_OverrideBinaryOperatorHelper(pow, \"pow\")\n\n\n@tf_export(\"math.logical_xor\", v1=[\"math.logical_xor\", \"logical_xor\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"logical_xor\")\ndef logical_xor(x, y, name=\"LogicalXor\"):\n \"\"\"x ^ y = (x | y) & ~(x & y).\"\"\"\n # TODO(alemi) Make this a cwise op if people end up relying on it.\n return gen_math_ops.logical_and(\n gen_math_ops.logical_or(x, y),\n gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)),\n name=name)\n\n\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_and, \"and\")\n_OverrideBinaryOperatorHelper(gen_math_ops.logical_or, \"or\")\n_OverrideBinaryOperatorHelper(logical_xor, \"xor\")\n\nops.Tensor._override_operator(\"__lt__\", gen_math_ops.less)\nops.Tensor._override_operator(\"__le__\", gen_math_ops.less_equal)\nops.Tensor._override_operator(\"__gt__\", gen_math_ops.greater)\nops.Tensor._override_operator(\"__ge__\", gen_math_ops.greater_equal)\n\n\n@tf_export(\"range\")\ndef range(start, limit=None, delta=1, dtype=None, name=\"range\"): # pylint: disable=redefined-builtin\n \"\"\"Creates a sequence of numbers.\n\n Creates a sequence of numbers that begins at `start` and extends by\n increments of `delta` up to but not including `limit`.\n\n The dtype of the resulting tensor is inferred from the inputs unless\n it is provided explicitly.\n\n Like the Python builtin `range`, `start` defaults to 0, so that\n `range(n) = range(0, n)`.\n\n For example:\n\n ```python\n start = 3\n limit = 18\n delta = 3\n tf.range(start, limit, delta) # [3, 6, 9, 12, 15]\n\n start = 3\n limit = 1\n delta = -0.5\n tf.range(start, limit, delta) # [3, 2.5, 2, 1.5]\n\n limit = 5\n tf.range(limit) # [0, 1, 2, 3, 4]\n ```\n\n Args:\n start: A 0-D `Tensor` (scalar). Acts as first entry in the range if\n `limit` is not None; otherwise, acts as range limit and first entry\n defaults to 0.\n limit: A 0-D `Tensor` (scalar). Upper limit of sequence,\n exclusive. If None, defaults to the value of `start` while the first\n entry of the range defaults to 0.\n delta: A 0-D `Tensor` (scalar). Number that increments\n `start`. Defaults to 1.\n dtype: The type of the elements of the resulting tensor.\n name: A name for the operation. Defaults to \"range\".\n\n Returns:\n An 1-D `Tensor` of type `dtype`.\n\n @compatibility(numpy)\n Equivalent to np.arange\n @end_compatibility\n \"\"\"\n if limit is None:\n start, limit = 0, start\n\n with ops.name_scope(name, \"Range\", [start, limit, delta]) as name:\n start = ops.convert_to_tensor(start, dtype=dtype, name=\"start\")\n limit = ops.convert_to_tensor(limit, dtype=dtype, name=\"limit\")\n delta = ops.convert_to_tensor(delta, dtype=dtype, name=\"delta\")\n\n # infer dtype if not explicitly provided\n if dtype is None:\n dtype_hierarchy = [\n dtypes.int32, dtypes.int64, dtypes.float32, dtypes.float64\n ]\n assert all(arg.dtype in dtype_hierarchy for arg in [start, limit, delta])\n inferred_dtype = max(\n [arg.dtype for arg in [start, limit, delta]],\n key=dtype_hierarchy.index)\n\n start = cast(start, inferred_dtype)\n limit = cast(limit, inferred_dtype)\n delta = cast(delta, inferred_dtype)\n\n return gen_math_ops._range(start, limit, delta, name=name)\n\n\n# Reduction operations\ndef _ReductionDims(x, axis, reduction_indices=None): # pylint: disable=invalid-name\n \"\"\"Returns range(0, rank(x)) if reduction_indices is None.\"\"\"\n # TODO(aselle): Remove this after deprecation\n if reduction_indices is not None:\n if axis is not None:\n raise ValueError(\"Can't specify both axis' and 'reduction_indices'.\")\n axis = reduction_indices\n if axis is not None:\n return axis\n else:\n # Fast path: avoid creating Rank and Range ops if ndims is known.\n rank = common_shapes.rank(x)\n if rank is not None:\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n if (isinstance(x, sparse_tensor.SparseTensor) and\n x.dense_shape.shape.is_fully_defined()):\n rank = x.dense_shape.shape.dims[0].value # sparse.dense_shape is 1-D.\n return constant_op.constant(np.arange(rank), dtype=dtypes.int32)\n\n # Otherwise, we rely on Range and Rank to do the right thing at run-time.\n return range(0, array_ops.rank(x))\n\n\ndef _may_reduce_to_scalar(keepdims, axis, output):\n \"\"\"Set a reduction's output shape to be a scalar if we are certain.\"\"\"\n if not common_shapes.has_fully_defined_shape(output) and (not keepdims) and (\n axis is None):\n output.set_shape(())\n return output\n\n\n@tf_export(v1=[\"math.reduce_sum\", \"reduce_sum\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_sum_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_sum(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_sum\", \"reduce_sum\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_sum(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the sum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1, 1, 1], [1, 1, 1]])\n tf.reduce_sum(x) # 6\n tf.reduce_sum(x, 0) # [2, 2, 2]\n tf.reduce_sum(x, 1) # [3, 3]\n tf.reduce_sum(x, 1, keepdims=True) # [[3], [3]]\n tf.reduce_sum(x, [0, 1]) # 6\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to\n int64 while tensorflow returns the same dtype as the input.\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._sum(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.count_nonzero\", \"count_nonzero\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\n@deprecation.deprecated_args(\n None, \"reduction_indices is deprecated, use axis instead\", \"axis\")\ndef count_nonzero(input_tensor,\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis,\n \"reduction_indices\", reduction_indices\n )\n\n return count_nonzero_v2(input_tensor, axis, keepdims, dtype, name)\n\n\n@tf_export(\"math.count_nonzero\", v1=[])\ndef count_nonzero_v2(input, # pylint: disable=redefined-builtin\n axis=None,\n keepdims=None,\n dtype=dtypes.int64,\n name=None):\n \"\"\"Computes number of nonzero elements across dimensions of a tensor.\n\n Reduces `input` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n **NOTE** Floating point comparison to zero is done by exact floating point\n equality check. Small values are **not** rounded to zero for purposes of\n the nonzero check.\n\n For example:\n\n ```python\n x = tf.constant([[0, 1, 0], [1, 1, 0]])\n tf.count_nonzero(x) # 3\n tf.count_nonzero(x, 0) # [1, 2, 0]\n tf.count_nonzero(x, 1) # [1, 2]\n tf.count_nonzero(x, 1, keepdims=True) # [[1], [2]]\n tf.count_nonzero(x, [0, 1]) # 3\n ```\n\n **NOTE** Strings are compared against zero-length empty string `\"\"`. Any\n string with a size greater than zero is already considered as nonzero.\n\n For example:\n ```python\n x = tf.constant([\"\", \"a\", \" \", \"b\", \"\"])\n tf.count_nonzero(x) # 3, with \"a\", \" \", and \"b\" as nonzero strings.\n ```\n\n Args:\n input: The tensor to reduce. Should be of numeric type, `bool`,\n or `string`.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input), rank(input))`.\n keepdims: If true, retains reduced dimensions with length 1.\n dtype: The output dtype; defaults to `tf.int64`.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor (number of nonzero values).\n \"\"\"\n if keepdims is None:\n keepdims = False\n with ops.name_scope(name, \"count_nonzero\", [input]):\n input = ops.convert_to_tensor(input, name=\"input\")\n # A scalar of 'zero' is enough as `not_equal` will broadcast.\n zero = array_ops.zeros([], dtype=input.dtype)\n return cast(\n reduce_sum(\n # int64 reduction happens on GPU\n cast(gen_math_ops.not_equal(input, zero), dtypes.int64),\n axis=axis,\n keepdims=keepdims),\n dtype=dtype)\n\n\n@tf_export(v1=[\"math.reduce_mean\", \"reduce_mean\"])\ndef reduce_mean_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_mean(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_mean\", \"reduce_mean\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_mean(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the mean of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 1.], [2., 2.]])\n tf.reduce_mean(x) # 1.5\n tf.reduce_mean(x, 0) # [1.5, 1.5]\n tf.reduce_mean(x, 1) # [1., 2.]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.mean\n\n Please note that `np.mean` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`,\n for example:\n\n ```python\n x = tf.constant([1, 0, 1, 0])\n tf.reduce_mean(x) # 0\n y = tf.constant([1., 0., 1., 0.])\n tf.reduce_mean(y) # 0.5\n ```\n\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.mean(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(\"math.reduce_variance\")\ndef reduce_variance(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the variance of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_variance(x) # 1.25\n tf.reduce_variance(x, 0) # [1., 1.]\n tf.reduce_variance(x, 1) # [0.25, 0.25]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.var\n\n Please note that `np.var` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_variance` has an aggressive type inference from\n `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_variance\"\n with ops.name_scope(name):\n means = reduce_mean(input_tensor, axis=axis, keepdims=True)\n squared_deviations = gen_math_ops.square(input_tensor - means)\n return reduce_mean(squared_deviations, axis=axis, keepdims=keepdims)\n\n\n@tf_export(\"math.reduce_std\")\ndef reduce_std(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the standard deviation of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[1., 2.], [3., 4.]])\n tf.reduce_std(x) # 1.1180339887498949\n tf.reduce_std(x, 0) # [1., 1.]\n tf.reduce_std(x, 1) # [0.5, 0.5]\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name scope for the associated operations (optional).\n\n Returns:\n The reduced tensor, of the same dtype as the input_tensor.\n\n @compatibility(numpy)\n Equivalent to np.std\n\n Please note that `np.std` has a `dtype` parameter that could be used to\n specify the output type. By default this is `dtype=float64`. On the other\n hand, `tf.reduce_std` has an aggressive type inference from `input_tensor`,\n @end_compatibility\n \"\"\"\n name = name if name else \"reduce_std\"\n with ops.name_scope(name):\n variance = reduce_variance(input_tensor, axis=axis, keepdims=keepdims)\n return gen_math_ops.sqrt(variance)\n\n\n@tf_export(\"math.reduce_prod\", \"reduce_prod\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_prod(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops.prod(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_prod\", \"reduce_prod\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_prod_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the product of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.prod\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_prod(input_tensor, axis, keepdims, name)\n\n\n@tf_export(v1=[\"math.reduce_min\", \"reduce_min\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_min_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_min(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_min\", \"reduce_min\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_min(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the minimum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.min\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._min(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_max\", \"reduce_max\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_max_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default),\n reduces all dimensions. Must be in the range\n `[-rank(input_tensor), rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_max(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_max\", \"reduce_max\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_max(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the maximum of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n Args:\n input_tensor: The tensor to reduce. Should have real numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.max\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._max(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_all\", \"reduce_all\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_all_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_all(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"reduce_all\", \"math.reduce_all\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_all(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical and\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_all(x) # False\n tf.reduce_all(x, 0) # [False, False]\n tf.reduce_all(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.all\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._all(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_any\", \"reduce_any\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_any_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_any(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_any\", \"reduce_any\", v1=[])\n@dispatch.add_dispatch_support\ndef reduce_any(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes the \"logical or\" of elements across dimensions of a tensor.\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` is None, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n For example:\n\n ```python\n x = tf.constant([[True, True], [False, False]])\n tf.reduce_any(x) # True\n tf.reduce_any(x, 0) # [True, True]\n tf.reduce_any(x, 1) # [True, False]\n ```\n\n Args:\n input_tensor: The boolean tensor to reduce.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n\n @compatibility(numpy)\n Equivalent to np.any\n @end_compatibility\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n return _may_reduce_to_scalar(\n keepdims, axis,\n gen_math_ops._any(\n input_tensor, _ReductionDims(input_tensor, axis), keepdims,\n name=name))\n\n\n@tf_export(v1=[\"math.reduce_logsumexp\", \"reduce_logsumexp\"])\n@deprecation.deprecated_args(\n None, \"keep_dims is deprecated, use keepdims instead\", \"keep_dims\")\ndef reduce_logsumexp_v1(input_tensor,\n axis=None,\n keepdims=None,\n name=None,\n reduction_indices=None,\n keep_dims=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n reduction_indices: The old (deprecated) name for axis.\n keep_dims: Deprecated alias for `keepdims`.\n\n Returns:\n The reduced tensor.\n \"\"\"\n axis = deprecation.deprecated_argument_lookup(\n \"axis\", axis, \"reduction_indices\", reduction_indices)\n keepdims = deprecation.deprecated_argument_lookup(\"keepdims\", keepdims,\n \"keep_dims\", keep_dims)\n return reduce_logsumexp(input_tensor, axis, keepdims, name)\n\n\n@tf_export(\"math.reduce_logsumexp\", \"reduce_logsumexp\", v1=[])\ndef reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):\n \"\"\"Computes log(sum(exp(elements across dimensions of a tensor))).\n\n Reduces `input_tensor` along the dimensions given in `axis`.\n Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each\n entry in `axis`. If `keepdims` is true, the reduced dimensions\n are retained with length 1.\n\n If `axis` has no entries, all dimensions are reduced, and a\n tensor with a single element is returned.\n\n This function is more numerically stable than log(sum(exp(input))). It avoids\n overflows caused by taking the exp of large inputs and underflows caused by\n taking the log of small inputs.\n\n For example:\n\n ```python\n x = tf.constant([[0., 0., 0.], [0., 0., 0.]])\n tf.reduce_logsumexp(x) # log(6)\n tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)]\n tf.reduce_logsumexp(x, 1) # [log(3), log(3)]\n tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]]\n tf.reduce_logsumexp(x, [0, 1]) # log(6)\n ```\n\n Args:\n input_tensor: The tensor to reduce. Should have numeric type.\n axis: The dimensions to reduce. If `None` (the default), reduces all\n dimensions. Must be in the range `[-rank(input_tensor),\n rank(input_tensor))`.\n keepdims: If true, retains reduced dimensions with length 1.\n name: A name for the operation (optional).\n\n Returns:\n The reduced tensor.\n \"\"\"\n keepdims = False if keepdims is None else keepdims\n input_tensor = ops.convert_to_tensor(input_tensor)\n with ops.name_scope(name, \"ReduceLogSumExp\", [input_tensor]) as name:\n raw_max = reduce_max(\n input_tensor,\n axis=axis,\n keepdims=True)\n my_max = array_ops.stop_gradient(\n array_ops.where(\n gen_math_ops.is_finite(raw_max), raw_max,\n array_ops.zeros_like(raw_max)))\n result = gen_math_ops.log(\n reduce_sum(\n gen_math_ops.exp(gen_math_ops.sub(input_tensor, my_max)),\n axis,\n keepdims=keepdims))\n if not keepdims:\n my_max = array_ops.reshape(my_max, array_ops.shape(result))\n result = gen_math_ops.add(result, my_max)\n return _may_reduce_to_scalar(keepdims, axis, result)\n\n\n@tf_export(\"linalg.trace\", v1=[\"linalg.trace\", \"trace\"])\n@deprecation.deprecated_endpoints(\"trace\")\ndef trace(x, name=None):\n \"\"\"Compute the trace of a tensor `x`.\n\n `trace(x)` returns the sum along the main diagonal of each inner-most matrix\n in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output\n is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where\n\n `output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`\n\n For example:\n\n ```python\n x = tf.constant([[1, 2], [3, 4]])\n tf.linalg.trace(x) # 5\n\n x = tf.constant([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\n tf.linalg.trace(x) # 15\n\n x = tf.constant([[[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]],\n [[-1, -2, -3],\n [-4, -5, -6],\n [-7, -8, -9]]])\n tf.linalg.trace(x) # [15, -15]\n ```\n\n Args:\n x: tensor.\n name: A name for the operation (optional).\n\n Returns:\n The trace of input tensor.\n \"\"\"\n with ops.name_scope(name, \"Trace\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return reduce_sum(array_ops.matrix_diag_part(x), [-1], name=name)\n\n\n@tf_export(\"linalg.matmul\", \"matmul\")\ndef matmul(a,\n b,\n transpose_a=False,\n transpose_b=False,\n adjoint_a=False,\n adjoint_b=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by matrix `b`, producing `a` * `b`.\n\n The inputs must, following any transpositions, be tensors of rank >= 2\n where the inner 2 dimensions specify valid matrix multiplication arguments,\n and any further outer dimensions match.\n\n Both matrices must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Either matrix can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the matrices contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices (rank-2 tensors) with\n datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 2-D tensor `b`\n # [[ 7, 8],\n # [ 9, 10],\n # [11, 12]]\n b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])\n\n # `a` * `b`\n # [[ 58, 64],\n # [139, 154]]\n c = tf.matmul(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 3-D tensor `b`\n # [[[13, 14],\n # [15, 16],\n # [17, 18]],\n # [[19, 20],\n # [21, 22],\n # [23, 24]]]\n b = tf.constant(np.arange(13, 25, dtype=np.int32),\n shape=[2, 3, 2])\n\n # `a` * `b`\n # [[[ 94, 100],\n # [229, 244]],\n # [[508, 532],\n # [697, 730]]]\n c = tf.matmul(a, b)\n\n # Since python >= 3.5 the @ operator is supported (see PEP 465).\n # In TensorFlow, it simply calls the `tf.matmul()` function, so the\n # following lines are equivalent:\n d = a @ b @ [[10.], [11.]]\n d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank as `a`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n transpose_b: If `True`, `b` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n adjoint_b: If `True`, `b` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most matrix is\n the product of the corresponding matrices in `a` and `b`, e.g. if all\n transpose or adjoint attributes are `False`:\n\n `output`[..., i, j] = sum_k (`a`[..., i, k] * `b`[..., k, j]),\n for all indices i, j.\n\n Note: This is matrix product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b\n are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatMul\", [a, b]) as name:\n if transpose_a and adjoint_a:\n raise ValueError(\"Only one of transpose_a and adjoint_a can be True.\")\n if transpose_b and adjoint_b:\n raise ValueError(\"Only one of transpose_b and adjoint_b can be True.\")\n\n if context.executing_eagerly():\n if not isinstance(a, (ops.EagerTensor, _resource_variable_type)):\n a = ops.convert_to_tensor(a, name=\"a\")\n if not isinstance(b, (ops.EagerTensor, _resource_variable_type)):\n b = ops.convert_to_tensor(b, name=\"b\")\n else:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n\n # TODO(apassos) remove _shape_tuple here when it is not needed.\n a_shape = a._shape_tuple() # pylint: disable=protected-access\n b_shape = b._shape_tuple() # pylint: disable=protected-access\n if (not a_is_sparse and\n not b_is_sparse) and ((a_shape is None or len(a_shape) > 2) and\n (b_shape is None or len(b_shape) > 2)):\n # BatchMatmul does not support transpose, so we conjugate the matrix and\n # use adjoint instead. Conj() is a noop for real matrices.\n if transpose_a:\n a = conj(a)\n adjoint_a = True\n if transpose_b:\n b = conj(b)\n adjoint_b = True\n return gen_math_ops.batch_mat_mul(\n a, b, adj_x=adjoint_a, adj_y=adjoint_b, name=name)\n\n # Neither matmul nor sparse_matmul support adjoint, so we conjugate\n # the matrix and use transpose instead. Conj() is a noop for real\n # matrices.\n if adjoint_a:\n a = conj(a)\n transpose_a = True\n if adjoint_b:\n b = conj(b)\n transpose_b = True\n\n use_sparse_matmul = False\n if a_is_sparse or b_is_sparse:\n sparse_matmul_types = [dtypes.bfloat16, dtypes.float32]\n use_sparse_matmul = (\n a.dtype in sparse_matmul_types and b.dtype in sparse_matmul_types)\n if ((a.dtype == dtypes.bfloat16 or b.dtype == dtypes.bfloat16) and\n a.dtype != b.dtype):\n # matmul currently doesn't handle mixed-precision inputs.\n use_sparse_matmul = True\n if use_sparse_matmul:\n ret = sparse_matmul(\n a,\n b,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse,\n name=name)\n # sparse_matmul always returns float32, even with\n # bfloat16 inputs. This prevents us from configuring bfloat16 training.\n # casting to bfloat16 also matches non-sparse matmul behavior better.\n if a.dtype == dtypes.bfloat16 and b.dtype == dtypes.bfloat16:\n ret = cast(ret, dtypes.bfloat16)\n return ret\n else:\n return gen_math_ops.mat_mul(\n a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\n\n@tf_export(\"linalg.matvec\")\ndef matvec(a,\n b,\n transpose_a=False,\n adjoint_a=False,\n a_is_sparse=False,\n b_is_sparse=False,\n name=None):\n \"\"\"Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n Both `a` and `b` must be of the same type. The supported types are:\n `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n the fly by setting one of the corresponding flag to `True`. These are `False`\n by default.\n\n If one or both of the inputs contain a lot of zeros, a more efficient\n multiplication algorithm can be used by setting the corresponding\n `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n This optimization is only available for plain matrices/vectors (rank-2/1\n tensors) with datatypes `bfloat16` or `float32`.\n\n For example:\n\n ```python\n # 2-D tensor `a`\n # [[1, 2, 3],\n # [4, 5, 6]]\n a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n # 1-D tensor `b`\n # [7, 9, 11]\n b = tf.constant([7, 9, 11], shape=[3])\n\n # `a` * `b`\n # [ 58, 64]\n c = tf.matvec(a, b)\n\n\n # 3-D tensor `a`\n # [[[ 1, 2, 3],\n # [ 4, 5, 6]],\n # [[ 7, 8, 9],\n # [10, 11, 12]]]\n a = tf.constant(np.arange(1, 13, dtype=np.int32),\n shape=[2, 2, 3])\n\n # 2-D tensor `b`\n # [[13, 14, 15],\n # [16, 17, 18]]\n b = tf.constant(np.arange(13, 19, dtype=np.int32),\n shape=[2, 3])\n\n # `a` * `b`\n # [[ 86, 212],\n # [410, 563]]\n c = tf.matvec(a, b)\n ```\n\n Args:\n a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n `complex128` and rank > 1.\n b: `Tensor` with same type and rank = `rank(a) - 1`.\n transpose_a: If `True`, `a` is transposed before multiplication.\n adjoint_a: If `True`, `a` is conjugated and transposed before\n multiplication.\n a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n name: Name for the operation (optional).\n\n Returns:\n A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n all transpose or adjoint attributes are `False`:\n\n `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n Note: This is matrix-vector product, not element-wise product.\n\n\n Raises:\n ValueError: If transpose_a and adjoint_a are both set to True.\n \"\"\"\n with ops.name_scope(name, \"MatVec\", [a, b]) as name:\n output = matmul(\n a,\n array_ops.expand_dims(b, axis=-1),\n transpose_a=transpose_a,\n adjoint_a=adjoint_a,\n a_is_sparse=a_is_sparse,\n b_is_sparse=b_is_sparse)\n return array_ops.squeeze(output, axis=-1)\n\n\n_OverrideBinaryOperatorHelper(matmul, \"matmul\")\n\nsparse_matmul = deprecation.deprecated(None, \"Use `tf.linalg.matmul` instead\")(\n gen_math_ops.sparse_mat_mul)\ntf_export(v1=[\"sparse_matmul\"])(sparse_matmul)\n\n\n@ops.RegisterStatistics(\"MatMul\", \"flops\")\ndef _calc_mat_mul_flops(graph, node):\n \"\"\"Calculates the compute resources needed for MatMul.\"\"\"\n transpose_a = node.attr[\"transpose_a\"].b\n a_shape = graph_util.tensor_shape_from_node_def_name(graph, node.input[0])\n a_shape.assert_is_fully_defined()\n if transpose_a:\n k = int(a_shape[0])\n else:\n k = int(a_shape[1])\n output_shape = graph_util.tensor_shape_from_node_def_name(graph, node.name)\n output_shape.assert_is_fully_defined()\n output_count = np.prod(output_shape.as_list())\n return ops.OpStats(\"flops\", (k * output_count * 2))\n\n\ndef _as_indexed_slices(x, optimize=True):\n \"\"\"Convert 'x' to IndexedSlices.\n\n Convert a dense Tensor to a block-sparse IndexedSlices.\n\n Args:\n x: Either a Tensor object, or an IndexedSlices object.\n optimize: if true, attempt to optimize the conversion of 'x'.\n\n Returns:\n An IndexedSlices object.\n\n Raises:\n TypeError: If 'x' is not a Tensor or an IndexedSlices object.\n \"\"\"\n # TODO(touts): op_scope\n if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):\n raise TypeError(\"Not a Tensor or IndexedSlices: %s\" % type(x))\n if isinstance(x, ops.IndexedSlices):\n return x\n x_shape = array_ops.shape_internal(x, optimize=optimize)\n return ops.IndexedSlices(x, range(0, x_shape[0]), x_shape)\n\n\ndef _as_indexed_slices_list(inputs, optimize=True):\n \"\"\"Convert all elements of 'inputs' to IndexedSlices.\n\n Additionally, homogenize the types of all the indices to\n either int32 or int64.\n\n Args:\n inputs: List containing either Tensor or IndexedSlices objects.\n optimize: if true, attempt to optimize the conversion of each input.\n\n Returns:\n A list of IndexedSlices objects.\n\n Raises:\n TypeError: If 'inputs' is not a list or a tuple.\n \"\"\"\n if not isinstance(inputs, (list, tuple)):\n raise TypeError(\"Expected a list or tuple, not a %s\" % type(inputs))\n outputs = [_as_indexed_slices(i, optimize=optimize) for i in inputs]\n with_int32_index = [\n o.indices for o in outputs if o.indices.dtype == dtypes.int32\n ]\n if not with_int32_index or len(with_int32_index) == len(outputs):\n return outputs\n casted_outputs = []\n for o in outputs:\n if o.indices.dtype == dtypes.int32:\n casted_outputs.append(\n ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),\n o.dense_shape))\n else:\n casted_outputs.append(o)\n return casted_outputs\n\n\n@tf_export(\"math.add_n\", \"add_n\")\n@dispatch.add_dispatch_support\ndef add_n(inputs, name=None):\n \"\"\"Adds all input tensors element-wise.\n\n Converts `IndexedSlices` objects into dense tensors prior to adding.\n\n Args:\n inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape\n and type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, (ops.Tensor, ops.IndexedSlices)) for x in inputs):\n raise ValueError(\"inputs must be a list of at least one \"\n \"Tensor/IndexedSlices with the same dtype and shape\")\n\n if len(inputs) == 1:\n if isinstance(inputs[0], ops.IndexedSlices):\n values = ops.convert_to_tensor(inputs[0])\n else:\n values = inputs[0]\n if name:\n return array_ops.identity(values, name=name)\n return values\n return gen_math_ops.add_n(inputs, name=name)\n\n\n@tf_export(\"math.accumulate_n\", v1=[\"math.accumulate_n\", \"accumulate_n\"])\n@deprecation.deprecated_endpoints(\"accumulate_n\")\ndef accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):\n \"\"\"Returns the element-wise sum of a list of tensors.\n\n Optionally, pass `shape` and `tensor_dtype` for shape and type checking,\n otherwise, these are inferred.\n\n `tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not\n wait for all of its inputs to be ready before beginning to sum. This can\n save memory if inputs are ready at different times, since minimum temporary\n storage is proportional to the output size rather than the inputs size.\n\n `accumulate_n` is differentiable (but wasn't previous to TensorFlow 1.7).\n\n For example:\n\n ```python\n a = tf.constant([[1, 2], [3, 4]])\n b = tf.constant([[5, 0], [0, 6]])\n tf.math.accumulate_n([a, b, a]) # [[7, 4], [6, 14]]\n\n # Explicitly pass shape and type\n tf.math.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)\n # [[7, 4],\n # [6, 14]]\n ```\n\n Args:\n inputs: A list of `Tensor` objects, each with same shape and type.\n shape: Shape of elements of `inputs`.\n tensor_dtype: The type of `inputs`.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of same shape and type as the elements of `inputs`.\n\n Raises:\n ValueError: If `inputs` don't all have same shape and dtype or the shape\n cannot be inferred.\n \"\"\"\n\n def _input_error():\n return ValueError(\"inputs must be a list of at least one Tensor with the \"\n \"same dtype and shape\")\n\n if not inputs or not isinstance(inputs, (list, tuple)):\n raise _input_error()\n inputs = ops.convert_n_to_tensor_or_indexed_slices(inputs)\n if not all(isinstance(x, ops.Tensor) for x in inputs):\n raise _input_error()\n if not all(x.dtype == inputs[0].dtype for x in inputs):\n raise _input_error()\n if shape is not None:\n shape = tensor_shape.as_shape(shape)\n else:\n shape = tensor_shape.unknown_shape()\n for input_tensor in inputs:\n if isinstance(input_tensor, ops.Tensor):\n shape = shape.merge_with(input_tensor.get_shape())\n\n # tensor_dtype is for safety only; operator's output type computed in C++\n if tensor_dtype is not None and tensor_dtype != inputs[0].dtype:\n raise TypeError(\"tensor_dtype is {}, but input is of type {}\".format(\n tensor_dtype, inputs[0].dtype))\n\n if len(inputs) == 1 and name is None:\n return inputs[0]\n elif len(inputs) == 1 and name is not None:\n return array_ops.identity(inputs[0], name=name)\n elif context.executing_eagerly():\n # TemporaryVariable not currently supported in eager mode; fall back\n # onto AddN for now.\n # TODO(frreiss) remove this once the lifetime of eager variables gets\n # addressed\n return add_n(inputs, name=name)\n else:\n return gen_math_ops.accumulate_nv2(inputs, name=name, shape=shape) # pylint: disable=protected-access\n\n\n@ops.RegisterGradient(\"AccumulateNV2\")\ndef _accumulate_n_grad(op, grad):\n \"\"\"Same as gradient for AddN. Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\n@tf_export(\"math.sigmoid\", \"nn.sigmoid\", \"sigmoid\")\ndef sigmoid(x, name=None):\n \"\"\"Computes sigmoid of `x` element-wise.\n\n Specifically, `y = 1 / (1 + exp(-x))`.\n\n Args:\n x: A Tensor with type `float16`, `float32`, `float64`, `complex64`,\n or `complex128`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n\n @compatibility(scipy)\n Equivalent to scipy.special.expit\n @end_compatibility\n \"\"\"\n with ops.name_scope(name, \"Sigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.sigmoid(x, name=name)\n\n\n@tf_export(\"math.log_sigmoid\", v1=[\"math.log_sigmoid\", \"log_sigmoid\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"log_sigmoid\")\ndef log_sigmoid(x, name=None):\n \"\"\"Computes log sigmoid of `x` element-wise.\n\n Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability,\n we use `y = -tf.nn.softplus(-x)`.\n\n Args:\n x: A Tensor with type `float32` or `float64`.\n name: A name for the operation (optional).\n\n Returns:\n A Tensor with the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"LogSigmoid\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.neg(gen_nn_ops.softplus(-x), name=name)\n\n\n@tf_export(\"math.bincount\", v1=[])\ndef bincount(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32,\n name=None):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n name: A name scope for the associated operations (optional).\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n name = \"bincount\" if name is None else name\n with ops.name_scope(name):\n arr = ops.convert_to_tensor(arr, name=\"arr\", dtype=dtypes.int32)\n array_is_nonempty = reduce_prod(array_ops.shape(arr)) > 0\n output_size = cast(array_is_nonempty, dtypes.int32) * (reduce_max(arr) + 1)\n if minlength is not None:\n minlength = ops.convert_to_tensor(\n minlength, name=\"minlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.maximum(minlength, output_size)\n if maxlength is not None:\n maxlength = ops.convert_to_tensor(\n maxlength, name=\"maxlength\", dtype=dtypes.int32)\n output_size = gen_math_ops.minimum(maxlength, output_size)\n if weights is not None:\n weights = ops.convert_to_tensor(weights, name=\"weights\")\n return gen_math_ops.unsorted_segment_sum(weights, arr, output_size)\n weights = constant_op.constant([], dtype)\n return gen_math_ops.bincount(arr, output_size, weights)\n\n\n@tf_export(v1=[\"math.bincount\", \"bincount\"])\n@deprecation.deprecated_endpoints(\"bincount\")\ndef bincount_v1(arr,\n weights=None,\n minlength=None,\n maxlength=None,\n dtype=dtypes.int32):\n \"\"\"Counts the number of occurrences of each value in an integer array.\n\n If `minlength` and `maxlength` are not given, returns a vector with length\n `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.\n If `weights` are non-None, then index `i` of the output stores the sum of the\n value in `weights` at each index where the corresponding value in `arr` is\n `i`.\n\n Args:\n arr: An int32 tensor of non-negative values.\n weights: If non-None, must be the same shape as arr. For each value in\n `arr`, the bin will be incremented by the corresponding weight instead of\n 1.\n minlength: If given, ensures the output has length at least `minlength`,\n padding with zeros at the end if necessary.\n maxlength: If given, skips values in `arr` that are equal or greater than\n `maxlength`, ensuring that the output has length at most `maxlength`.\n dtype: If `weights` is None, determines the type of the output bins.\n\n Returns:\n A vector with the same dtype as `weights` or the given `dtype`. The bin\n values.\n \"\"\"\n return bincount(arr, weights, minlength, maxlength, dtype)\n\n\n@tf_export(\"math.cumsum\", \"cumsum\")\ndef cumsum(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative sum of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumsum, which means that the first\n element of the input is identical to the first element of the output:\n\n ```python\n tf.cumsum([a, b, c]) # [a, a + b, a + b + c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed\n instead:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True) # [0, a, a + b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumsum is performed in the\n opposite direction:\n\n ```python\n tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumsum.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumsum\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumsum(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.cumprod\", v1=[\"math.cumprod\", \"cumprod\"])\n@deprecation.deprecated_endpoints(\"cumprod\")\ndef cumprod(x, axis=0, exclusive=False, reverse=False, name=None):\n \"\"\"Compute the cumulative product of the tensor `x` along `axis`.\n\n By default, this op performs an inclusive cumprod, which means that the\n first element of the input is identical to the first element of the output:\n\n ```python\n tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c]\n ```\n\n By setting the `exclusive` kwarg to `True`, an exclusive cumprod is\n performed\n instead:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b]\n ```\n\n By setting the `reverse` kwarg to `True`, the cumprod is performed in the\n opposite direction:\n\n ```python\n tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c]\n ```\n\n This is more efficient than using separate `tf.reverse` ops.\n The `reverse` and `exclusive` kwargs can also be combined:\n\n ```python\n tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1]\n ```\n\n Args:\n x: A `Tensor`. Must be one of the following types: `float32`, `float64`,\n `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,\n `complex128`, `qint8`, `quint8`, `qint32`, `half`.\n axis: A `Tensor` of type `int32` (default: 0). Must be in the range\n `[-rank(x), rank(x))`.\n exclusive: If `True`, perform exclusive cumprod.\n reverse: A `bool` (default: False).\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has the same type as `x`.\n \"\"\"\n with ops.name_scope(name, \"Cumprod\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n return gen_math_ops.cumprod(\n x, axis, exclusive=exclusive, reverse=reverse, name=name)\n\n\n@tf_export(\"math.conj\", v1=[\"math.conj\", \"conj\"])\n@dispatch.add_dispatch_support\n@deprecation.deprecated_endpoints(\"conj\")\ndef conj(x, name=None):\n r\"\"\"Returns the complex conjugate of a complex number.\n\n Given a tensor `input` of complex numbers, this operation returns a tensor of\n complex numbers that are the complex conjugate of each element in `input`. The\n complex numbers in `input` must be of the form \\\\(a + bj\\\\), where *a* is the\n real part and *b* is the imaginary part.\n\n The complex conjugate returned by this operation is of the form \\\\(a - bj\\\\).\n\n For example:\n\n # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]\n tf.math.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]\n\n If `x` is real, it is returned unchanged.\n\n Args:\n x: `Tensor` to conjugate. Must have numeric or variant type.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` that is the conjugate of `x` (with the same type).\n\n Raises:\n TypeError: If `x` is not a numeric tensor.\n \"\"\"\n if isinstance(x, ops.Tensor):\n dt = x.dtype\n if dt.is_floating or dt.is_integer:\n return x\n with ops.name_scope(name, \"Conj\", [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if x.dtype.is_complex or x.dtype == dtypes.variant:\n return gen_math_ops.conj(x, name=name)\n elif x.dtype.is_floating or x.dtype.is_integer:\n return x\n else:\n raise TypeError(\n \"Expected numeric or variant tensor, got dtype %r\" % x.dtype)\n\n\ndef _BroadcastShape(op):\n \"\"\"Common shape function for binary operators that broadcast their inputs.\"\"\"\n return [\n common_shapes.broadcast_shape(op.inputs[0].get_shape(),\n op.inputs[1].get_shape())\n ]\n\n\ndef reduced_shape(input_shape, axes):\n \"\"\"Helper function for reduction ops.\n\n Args:\n input_shape: 1-D Tensor, the shape of the Tensor being reduced.\n axes: 1-D Tensor, the reduction axes.\n Returns:\n A 1-D Tensor, the output shape as if keepdims were set to True.\n \"\"\"\n # Example:\n # cast needed for SparseTensor reductions\n if context.executing_eagerly():\n input_shape = input_shape.numpy()\n axes = axes.numpy()\n input_shape[axes] = 1\n return input_shape\n\n input_shape = cast(input_shape, dtypes.int32) # [2, 3, 5, 7]\n axes = cast(axes, dtypes.int32) # [1, 2]\n\n input_rank = array_ops.size(input_shape) # 4\n axes = (axes + input_rank) % input_rank\n axes_shape = array_ops.shape(axes) # [2]\n return gen_data_flow_ops.dynamic_stitch( # [2, 1, 1, 7]\n [\n range(input_rank), # [0, 1, 2, 3]\n axes\n ], # [1, 2]\n [\n input_shape, # [2, 3, 5, 7]\n array_ops.fill(axes_shape, 1)\n ]) # [1, 1]\n\n\ndef _unsorted_segment_N(data, segment_ids, num_segments):\n \"\"\" Helper function for unsorted_segment_mean/_sqrtN. Computes the number\n of segment entries with 0-entries set to 1 to allow division by N.\n \"\"\"\n # bincount doesn't support negative indices so we use unsorted_segment_sum\n segment_ids_shape = array_ops.shape_internal(segment_ids)\n ones_tensor = array_ops.ones(segment_ids_shape, dtype=data.dtype)\n N = gen_math_ops.unsorted_segment_sum(ones_tensor, segment_ids, num_segments)\n # add dimensions for all non-reduced axes\n ndims_output = data.shape.ndims - segment_ids.shape.ndims\n broadcast_shape = [num_segments] + [1] * ndims_output\n N = array_ops.reshape(N, broadcast_shape)\n return gen_math_ops.maximum(N, 1)\n\n\n@tf_export(\n \"math.unsorted_segment_mean\",\n v1=[\"math.unsorted_segment_mean\", \"unsorted_segment_mean\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_mean\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_mean(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the mean along segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Instead of computing the sum over segments, it computes the mean of all\n entries belonging to a segment such that:\n\n \\\\(output_i = 1/N_i \\sum_{j...} data[j...]\\\\) where the sum is over tuples\n `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the number of\n occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentMean\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / N\n\n\n@tf_export(\n \"math.unsorted_segment_sqrt_n\",\n v1=[\"math.unsorted_segment_sqrt_n\", \"unsorted_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"unsorted_segment_sqrt_n\")\n@dispatch.add_dispatch_support\ndef unsorted_segment_sqrt_n(data, segment_ids, num_segments, name=None):\n r\"\"\"Computes the sum along segments of a tensor divided by the sqrt(N).\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#segmentation)\n for an explanation of segments.\n\n This operator is similar to the unsorted segment sum operator found\n [here](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).\n Additionally to computing the sum over segments, it divides the results by\n sqrt(N).\n\n \\\\(output_i = 1/sqrt(N_i) \\sum_{j...} data[j...]\\\\) where the sum is over\n tuples `j...` such that `segment_ids[j...] == i` with \\\\N_i\\\\ being the\n number of occurrences of id \\\\i\\\\.\n\n If there is no entry for a given segment ID `i`, it outputs 0.\n\n Note that this op only supports floating point and complex dtypes,\n due to tf.sqrt only supporting these types.\n\n If the given segment ID `i` is negative, the value is dropped and will not\n be added to the sum of the segment.\n\n Args:\n data: A `Tensor` with floating point or complex dtype.\n segment_ids: An integer tensor whose shape is a prefix of `data.shape`.\n num_segments: An integer scalar `Tensor`. The number of distinct\n segment IDs.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor`. Has same shape as data, except for the first `segment_ids.rank`\n dimensions, which are replaced with a single dimension which has size\n `num_segments`.\n \"\"\"\n with ops.name_scope(name, \"UnsortedSegmentSqrtN\"):\n data = ops.convert_to_tensor(data)\n segment_ids = ops.convert_to_tensor(segment_ids)\n N = _unsorted_segment_N(data, segment_ids, num_segments)\n summed = gen_math_ops.unsorted_segment_sum(data, segment_ids, num_segments)\n return summed / gen_math_ops.sqrt(N)\n\n\n@tf_export(v1=[\"sparse.segment_sum\", \"sparse_segment_sum\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sum\")\ndef sparse_segment_sum(data, indices, segment_ids, name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n For example:\n\n ```python\n c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])\n\n # Select two rows, one segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))\n # => [[0 0 0 0]]\n\n # Select two rows, two segment.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))\n # => [[ 1 2 3 4]\n # [-1 -2 -3 -4]]\n\n # With missing segment ids.\n tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]),\n num_segments=4)\n # => [[ 1 2 3 4]\n # [ 0 0 0 0]\n # [-1 -2 -3 -4]\n # [ 0 0 0 0]]\n\n # Select all rows, two segments.\n tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))\n # => [[0 0 0 0]\n # [5 6 7 8]]\n\n # Which is equivalent to:\n tf.segment_sum(c, tf.constant([0, 0, 1]))\n ```\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sum_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sum(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sum\", v1=[])\ndef sparse_segment_sum_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_mean\", \"sparse_segment_mean\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_mean\")\ndef sparse_segment_mean(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_mean_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_mean(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_mean\", v1=[])\ndef sparse_segment_mean_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the mean along sparse segments of a tensor.\n\n Read [the section on\n segmentation](https://tensorflow.org/api_guides/python/math_ops#Segmentation)\n for an explanation of segments.\n\n Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first\n dimension, selecting a subset of dimension 0, specified by `indices`.\n `segment_ids` is allowed to have missing ids, in which case the output will\n be zeros at those indices. In those cases `num_segments` is used to determine\n the size of the output.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_mean(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(v1=[\"sparse.segment_sqrt_n\", \"sparse_segment_sqrt_n\"])\n@deprecation.deprecated_endpoints(\"sparse_segment_sqrt_n\")\ndef sparse_segment_sqrt_n(data,\n indices,\n segment_ids,\n name=None,\n num_segments=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`.\n Values should be sorted and can be repeated.\n name: A name for the operation (optional).\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n if num_segments is not None:\n return gen_math_ops.sparse_segment_sqrt_n_with_num_segments(\n data=data,\n indices=indices,\n segment_ids=segment_ids,\n num_segments=num_segments,\n name=name)\n else:\n return gen_math_ops.sparse_segment_sqrt_n(\n data=data, indices=indices, segment_ids=segment_ids, name=name)\n\n\n@tf_export(\"sparse.segment_sqrt_n\", v1=[])\ndef sparse_segment_sqrt_n_v2(data,\n indices,\n segment_ids,\n num_segments=None,\n name=None):\n r\"\"\"Computes the sum along sparse segments of a tensor divided by the sqrt(N).\n\n `N` is the size of the segment being reduced.\n\n Args:\n data: A `Tensor` with data that will be assembled in the output.\n indices: A 1-D `Tensor` with indices into `data`. Has same rank as\n `segment_ids`.\n segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values\n should be sorted and can be repeated.\n num_segments: An optional int32 scalar. Indicates the size of the output\n `Tensor`.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as data, except for dimension 0 which\n has size `k`, the number of segments specified via `num_segments` or\n inferred for the last element in `segments_ids`.\n \"\"\"\n return sparse_segment_sqrt_n(\n data, indices, segment_ids, name=name, num_segments=num_segments)\n\n\n@tf_export(\"tensordot\", \"linalg.tensordot\")\ndef tensordot(a, b, axes, name=None):\n r\"\"\"Tensor contraction of a and b along specified axes.\n\n Tensordot (also known as tensor contraction) sums the product of elements\n from `a` and `b` over the indices specified by `a_axes` and `b_axes`.\n The lists `a_axes` and `b_axes` specify those pairs of axes along which to\n contract the tensors. The axis `a_axes[i]` of `a` must have the same dimension\n as axis `b_axes[i]` of `b` for all `i` in `range(0, len(a_axes))`. The lists\n `a_axes` and `b_axes` must have identical length and consist of unique\n integers that specify valid axes for each of the tensors.\n\n This operation corresponds to `numpy.tensordot(a, b, axes)`.\n\n Example 1: When `a` and `b` are matrices (order 2), the case `axes = 1`\n is equivalent to matrix multiplication.\n\n Example 2: When `a` and `b` are matrices (order 2), the case\n `axes = [[1], [0]]` is equivalent to matrix multiplication.\n\n Example 3: Suppose that \\\\(a_{ijk}\\\\) and \\\\(b_{lmn}\\\\) represent two\n tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor\n \\\\(c_{jklm}\\\\) whose entry\n corresponding to the indices \\\\((j,k,l,m)\\\\) is given by:\n\n \\\\( c_{jklm} = \\sum_i a_{ijk} b_{lmi} \\\\).\n\n In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`.\n\n Args:\n a: `Tensor` of type `float32` or `float64`.\n b: `Tensor` with the same type as `a`.\n axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k].\n If axes is a scalar, sum over the last N axes of a and the first N axes of\n b in order. If axes is a list or `Tensor` the first and second row contain\n the set of unique integers specifying axes along which the contraction is\n computed, for `a` and `b`, respectively. The number of axes for `a` and\n `b` must be equal.\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` with the same type as `a`.\n\n Raises:\n ValueError: If the shapes of `a`, `b`, and `axes` are incompatible.\n IndexError: If the values in axes exceed the rank of the corresponding\n tensor.\n \"\"\"\n\n def _tensordot_reshape(a, axes, flipped=False):\n \"\"\"Helper method to perform transpose and reshape for contraction op.\n\n This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`\n using `array_ops.transpose` and `array_ops.reshape`. The method takes a\n tensor and performs the correct transpose and reshape operation for a given\n set of indices. It returns the reshaped tensor as well as a list of indices\n necessary to reshape the tensor again after matrix multiplication.\n\n Args:\n a: `Tensor`.\n axes: List or `int32` `Tensor` of unique indices specifying valid axes of\n `a`.\n flipped: An optional `bool`. Defaults to `False`. If `True`, the method\n assumes that `a` is the second argument in the contraction operation.\n\n Returns:\n A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is\n the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is\n either a list of integers or an `int32` `Tensor`, depending on whether\n the shape of a is fully specified, and free_dims_static is either a list\n of integers and None values, or None, representing the inferred\n static shape of the free dimensions\n \"\"\"\n if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n free_dims = [shape_a[i] for i in free]\n prod_free = int(np.prod([shape_a[i] for i in free]))\n prod_axes = int(np.prod([shape_a[i] for i in axes]))\n perm = list(axes) + free if flipped else free + list(axes)\n new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims\n else:\n if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):\n shape_a = a.get_shape().as_list()\n axes = [i if i >= 0 else i + len(shape_a) for i in axes]\n free = [i for i in xrange(len(shape_a)) if i not in axes]\n axes_dims = [shape_a[i] for i in axes]\n free_dims = [shape_a[i] for i in free]\n free_dims_static = free_dims\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n free = ops.convert_to_tensor(free, dtype=dtypes.int32, name=\"free\")\n shape_a = array_ops.shape(a)\n else:\n free_dims_static = None\n shape_a = array_ops.shape(a)\n rank_a = array_ops.rank(a)\n axes = ops.convert_to_tensor(axes, dtype=dtypes.int32, name=\"axes\")\n axes = array_ops.where(axes >= 0, axes, axes + rank_a)\n free, _ = array_ops.setdiff1d(range(rank_a), axes)\n free_dims = array_ops.gather(shape_a, free)\n axes_dims = array_ops.gather(shape_a, axes)\n prod_free_dims = reduce_prod(free_dims)\n prod_axes_dims = reduce_prod(axes_dims)\n if flipped:\n perm = array_ops.concat([axes, free], 0)\n new_shape = array_ops.stack([prod_axes_dims, prod_free_dims])\n else:\n perm = array_ops.concat([free, axes], 0)\n new_shape = array_ops.stack([prod_free_dims, prod_axes_dims])\n reshaped_a = array_ops.reshape(array_ops.transpose(a, perm), new_shape)\n return reshaped_a, free_dims, free_dims_static\n\n def _tensordot_axes(a, axes):\n \"\"\"Generates two sets of contraction axes for the two tensor arguments.\"\"\"\n a_shape = a.get_shape()\n if isinstance(axes, compat.integral_types):\n if axes < 0:\n raise ValueError(\"'axes' must be at least 0.\")\n if a_shape.ndims is not None:\n if axes > a_shape.ndims:\n raise ValueError(\"'axes' must not be larger than the number of \"\n \"dimensions of tensor %s.\" % a)\n return (list(xrange(a_shape.ndims - axes, a_shape.ndims)),\n list(xrange(axes)))\n else:\n rank = array_ops.rank(a)\n return (range(rank - axes, rank, dtype=dtypes.int32),\n range(axes, dtype=dtypes.int32))\n elif isinstance(axes, (list, tuple)):\n if len(axes) != 2:\n raise ValueError(\"'axes' must be an integer or have length 2.\")\n a_axes = axes[0]\n b_axes = axes[1]\n if isinstance(a_axes, compat.integral_types) and \\\n isinstance(b_axes, compat.integral_types):\n a_axes = [a_axes]\n b_axes = [b_axes]\n if len(a_axes) != len(b_axes):\n raise ValueError(\n \"Different number of contraction axes 'a' and 'b', %s != %s.\" %\n (len(a_axes), len(b_axes)))\n return a_axes, b_axes\n else:\n axes = ops.convert_to_tensor(axes, name=\"axes\", dtype=dtypes.int32)\n return axes[0], axes[1]\n\n with ops.name_scope(name, \"Tensordot\", [a, b, axes]) as name:\n a = ops.convert_to_tensor(a, name=\"a\")\n b = ops.convert_to_tensor(b, name=\"b\")\n a_axes, b_axes = _tensordot_axes(a, axes)\n a_reshape, a_free_dims, a_free_dims_static = _tensordot_reshape(a, a_axes)\n b_reshape, b_free_dims, b_free_dims_static = _tensordot_reshape(\n b, b_axes, True)\n ab_matmul = matmul(a_reshape, b_reshape)\n if isinstance(a_free_dims, list) and isinstance(b_free_dims, list):\n return array_ops.reshape(ab_matmul, a_free_dims + b_free_dims, name=name)\n else:\n a_free_dims = ops.convert_to_tensor(a_free_dims, dtype=dtypes.int32)\n b_free_dims = ops.convert_to_tensor(b_free_dims, dtype=dtypes.int32)\n product = array_ops.reshape(\n ab_matmul, array_ops.concat([a_free_dims, b_free_dims], 0), name=name)\n if a_free_dims_static is not None and b_free_dims_static is not None:\n product.set_shape(a_free_dims_static + b_free_dims_static)\n return product\n\n\n@tf_export(\"math.polyval\")\ndef polyval(coeffs, x, name=None):\n r\"\"\"Computes the elementwise value of a polynomial.\n\n If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns\n the value of the n-th order polynomial\n\n p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)\n\n evaluated using Horner's method, i.e.\n\n p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] +\n x * coeffs[0]))\n\n Args:\n coeffs: A list of `Tensor` representing the coefficients of the polynomial.\n x: A `Tensor` representing the variable of the polynomial.\n name: A name for the operation (optional).\n\n Returns:\n A `tensor` of the shape as the expression p(x) with usual broadcasting rules\n for element-wise addition and multiplication applied.\n\n @compatibility(numpy)\n Equivalent to numpy.polyval.\n @end_compatibility\n \"\"\"\n\n with ops.name_scope(name, \"polyval\", nest.flatten(coeffs) + [x]) as name:\n x = ops.convert_to_tensor(x, name=\"x\")\n if len(coeffs) < 1:\n return array_ops.zeros_like(x, name=name)\n coeffs = [\n ops.convert_to_tensor(coeff, name=(\"coeff_%d\" % index))\n for index, coeff in enumerate(coeffs)\n ]\n p = coeffs[0]\n for c in coeffs[1:]:\n p = c + p * x\n return p\n"}}},{"rowIdx":2065,"cells":{"function_name":{"kind":"string","value":"read_zfile"},"docstring":{"kind":"string","value":"Read the z-file and return the content as a string\n\nZ-files are raw data compressed with zlib used internally by joblib\nfor persistence. Backward compatibility is not guaranteed. Do not\nuse for external purposes."},"masked_code":{"kind":"string","value":"\"\"\"\nUtilities for fast persistence of big data, with optional compression.\n\"\"\"\n\n# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>\n# Copyright (c) 2009 Gael Varoquaux\n# License: BSD Style, 3 clauses.\n\nimport pickle\nimport traceback\nimport os\nimport zlib\nimport warnings\nfrom io import BytesIO\n\nfrom ._compat import _basestring, PY3_OR_LATER\n\n\nif PY3_OR_LATER:\n Unpickler = pickle._Unpickler\n Pickler = pickle._Pickler\n\n def asbytes(s):\n if isinstance(s, bytes):\n return s\n return s.encode('latin1')\nelse:\n Unpickler = pickle.Unpickler\n Pickler = pickle.Pickler\n asbytes = str\n\n\ndef hex_str(an_int):\n \"\"\"Converts an int to an hexadecimal string\n \"\"\"\n return '{0:#x}'.format(an_int)\n\n\n_MEGA = 2 ** 20\n\n# Compressed pickle header format: _ZFILE_PREFIX followed by _MAX_LEN\n# bytes which contains the length of the zlib compressed data as an\n# hexadecimal string. For example: 'ZF0x139 '\n_ZFILE_PREFIX = asbytes('ZF')\n_MAX_LEN = len(hex_str(2 ** 64))\n\n\n###############################################################################\n# Compressed file with Zlib\n\ndef _read_magic(file_handle):\n \"\"\" Utility to check the magic signature of a file identifying it as a\n Zfile\n \"\"\"\n magic = file_handle.read(len(_ZFILE_PREFIX))\n # Pickling needs file-handles at the beginning of the file\n file_handle.seek(0)\n return magic\n\n\n# MASKED: read_zfile function (lines 61-93)\n\n\ndef write_zfile(file_handle, data, compress=1):\n \"\"\"Write the data in the given file as a Z-file.\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guarantied. Do not\n use for external purposes.\n \"\"\"\n file_handle.write(_ZFILE_PREFIX)\n length = hex_str(len(data))\n # Store the length of the data\n file_handle.write(asbytes(length.ljust(_MAX_LEN)))\n file_handle.write(zlib.compress(asbytes(data), compress))\n\n\n###############################################################################\n# Utility objects for persistence.\n\nclass NDArrayWrapper(object):\n \"\"\" An object to be persisted instead of numpy arrays.\n\n The only thing this object does, is to carry the filename in which\n the array has been persisted, and the array subclass.\n \"\"\"\n def __init__(self, filename, subclass, allow_mmap=True):\n \"Store the useful information for later\"\n self.filename = filename\n self.subclass = subclass\n self.allow_mmap = allow_mmap\n\n def read(self, unpickler):\n \"Reconstruct the array\"\n filename = os.path.join(unpickler._dirname, self.filename)\n # Load the array from the disk\n np_ver = [int(x) for x in unpickler.np.__version__.split('.', 2)[:2]]\n\n # use getattr instead of self.allow_mmap to ensure backward compat\n # with NDArrayWrapper instances pickled with joblib < 0.9.0\n allow_mmap = getattr(self, 'allow_mmap', True)\n memmap_kwargs = ({} if not allow_mmap\n else {'mmap_mode': unpickler.mmap_mode})\n array = unpickler.np.load(filename, **memmap_kwargs)\n # Reconstruct subclasses. This does not work with old\n # versions of numpy\n if (hasattr(array, '__array_prepare__')\n and not self.subclass in (unpickler.np.ndarray,\n unpickler.np.memmap)):\n # We need to reconstruct another subclass\n new_array = unpickler.np.core.multiarray._reconstruct(\n self.subclass, (0,), 'b')\n new_array.__array_prepare__(array)\n array = new_array\n return array\n\n #def __reduce__(self):\n # return None\n\n\nclass ZNDArrayWrapper(NDArrayWrapper):\n \"\"\"An object to be persisted instead of numpy arrays.\n\n This object store the Zfile filename in which\n the data array has been persisted, and the meta information to\n retrieve it.\n\n The reason that we store the raw buffer data of the array and\n the meta information, rather than array representation routine\n (tostring) is that it enables us to use completely the strided\n model to avoid memory copies (a and a.T store as fast). In\n addition saving the heavy information separately can avoid\n creating large temporary buffers when unpickling data with\n large arrays.\n \"\"\"\n def __init__(self, filename, init_args, state):\n \"Store the useful information for later\"\n self.filename = filename\n self.state = state\n self.init_args = init_args\n\n def read(self, unpickler):\n \"Reconstruct the array from the meta-information and the z-file\"\n # Here we a simply reproducing the unpickling mechanism for numpy\n # arrays\n filename = os.path.join(unpickler._dirname, self.filename)\n array = unpickler.np.core.multiarray._reconstruct(*self.init_args)\n with open(filename, 'rb') as f:\n data = read_zfile(f)\n state = self.state + (data,)\n array.__setstate__(state)\n return array\n\n\n###############################################################################\n# Pickler classes\n\nclass NumpyPickler(Pickler):\n \"\"\"A pickler to persist of big data efficiently.\n\n The main features of this object are:\n\n * persistence of numpy arrays in separate .npy files, for which\n I/O is fast.\n\n * optional compression using Zlib, with a special care on avoid\n temporaries.\n \"\"\"\n dispatch = Pickler.dispatch.copy()\n\n def __init__(self, filename, compress=0, cache_size=10, protocol=None):\n self._filename = filename\n self._filenames = [filename, ]\n self.cache_size = cache_size\n self.compress = compress\n if not self.compress:\n self.file = open(filename, 'wb')\n else:\n self.file = BytesIO()\n # Count the number of npy files that we have created:\n self._npy_counter = 1\n # By default we want a pickle protocol that only changes with\n # the major python version and not the minor one\n if protocol is None:\n protocol = (pickle.DEFAULT_PROTOCOL if PY3_OR_LATER\n else pickle.HIGHEST_PROTOCOL)\n\n Pickler.__init__(self, self.file,\n protocol=protocol)\n # delayed import of numpy, to avoid tight coupling\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _write_array(self, array, filename):\n if not self.compress:\n self.np.save(filename, array)\n allow_mmap = not array.dtype.hasobject\n container = NDArrayWrapper(os.path.basename(filename),\n type(array),\n allow_mmap=allow_mmap)\n else:\n filename += '.z'\n # Efficient compressed storage:\n # The meta data is stored in the container, and the core\n # numerics in a z-file\n _, init_args, state = array.__reduce__()\n # the last entry of 'state' is the data itself\n with open(filename, 'wb') as zfile:\n write_zfile(zfile, state[-1], compress=self.compress)\n state = state[:-1]\n container = ZNDArrayWrapper(os.path.basename(filename),\n init_args, state)\n return container, filename\n\n def save(self, obj):\n \"\"\" Subclass the save method, to save ndarray subclasses in npy\n files, rather than pickling them. Of course, this is a\n total abuse of the Pickler class.\n \"\"\"\n if (self.np is not None and type(obj) in\n (self.np.ndarray, self.np.matrix, self.np.memmap)):\n size = obj.size * obj.itemsize\n if self.compress and size < self.cache_size * _MEGA:\n # When compressing, as we are not writing directly to the\n # disk, it is more efficient to use standard pickling\n if type(obj) is self.np.memmap:\n # Pickling doesn't work with memmaped arrays\n obj = self.np.asarray(obj)\n return Pickler.save(self, obj)\n\n if not obj.dtype.hasobject:\n try:\n filename = '%s_%02i.npy' % (self._filename,\n self._npy_counter)\n # This converts the array in a container\n obj, filename = self._write_array(obj, filename)\n self._filenames.append(filename)\n self._npy_counter += 1\n except Exception:\n # XXX: We should have a logging mechanism\n print('Failed to save %s to .npy file:\\n%s' % (\n type(obj),\n traceback.format_exc()))\n\n return Pickler.save(self, obj)\n\n def close(self):\n if self.compress:\n with open(self._filename, 'wb') as zfile:\n write_zfile(zfile, self.file.getvalue(), self.compress)\n\n\nclass NumpyUnpickler(Unpickler):\n \"\"\"A subclass of the Unpickler to unpickle our numpy pickles.\n \"\"\"\n dispatch = Unpickler.dispatch.copy()\n\n def __init__(self, filename, file_handle, mmap_mode=None):\n self._filename = os.path.basename(filename)\n self._dirname = os.path.dirname(filename)\n self.mmap_mode = mmap_mode\n self.file_handle = self._open_pickle(file_handle)\n Unpickler.__init__(self, self.file_handle)\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _open_pickle(self, file_handle):\n return file_handle\n\n def load_build(self):\n \"\"\" This method is called to set the state of a newly created\n object.\n\n We capture it to replace our place-holder objects,\n NDArrayWrapper, by the array we are interested in. We\n replace them directly in the stack of pickler.\n \"\"\"\n Unpickler.load_build(self)\n if isinstance(self.stack[-1], NDArrayWrapper):\n if self.np is None:\n raise ImportError('Trying to unpickle an ndarray, '\n \"but numpy didn't import correctly\")\n nd_array_wrapper = self.stack.pop()\n array = nd_array_wrapper.read(self)\n self.stack.append(array)\n\n # Be careful to register our new method.\n if PY3_OR_LATER:\n dispatch[pickle.BUILD[0]] = load_build\n else:\n dispatch[pickle.BUILD] = load_build\n\n\nclass ZipNumpyUnpickler(NumpyUnpickler):\n \"\"\"A subclass of our Unpickler to unpickle on the fly from\n compressed storage.\"\"\"\n\n def __init__(self, filename, file_handle):\n NumpyUnpickler.__init__(self, filename,\n file_handle,\n mmap_mode=None)\n\n def _open_pickle(self, file_handle):\n return BytesIO(read_zfile(file_handle))\n\n\n###############################################################################\n# Utility functions\n\ndef dump(value, filename, compress=0, cache_size=100, protocol=None):\n \"\"\"Fast persistence of an arbitrary Python object into one or multiple\n files, with dedicated storage for numpy arrays.\n\n Parameters\n -----------\n value: any Python object\n The object to store to disk\n filename: string\n The name of the file in which it is to be stored\n compress: integer for 0 to 9, optional\n Optional compression level for the data. 0 is no compression.\n Higher means more compression, but also slower read and\n write times. Using a value of 3 is often a good compromise.\n See the notes for more details.\n cache_size: positive number, optional\n Fixes the order of magnitude (in megabytes) of the cache used\n for in-memory compression. Note that this is just an order of\n magnitude estimate and that for big arrays, the code will go\n over this value at dump and at load time.\n protocol: positive int\n Pickle protocol, see pickle.dump documentation for more details.\n\n Returns\n -------\n filenames: list of strings\n The list of file names in which the data is stored. If\n compress is false, each array is stored in a different file.\n\n See Also\n --------\n joblib.load : corresponding loader\n\n Notes\n -----\n Memmapping on load cannot be used for compressed files. Thus\n using compression can significantly slow down loading. In\n addition, compressed files take extra extra memory during\n dump and load.\n \"\"\"\n if compress is True:\n # By default, if compress is enabled, we want to be using 3 by\n # default\n compress = 3\n if not isinstance(filename, _basestring):\n # People keep inverting arguments, and the resulting error is\n # incomprehensible\n raise ValueError(\n 'Second argument should be a filename, %s (type %s) was given'\n % (filename, type(filename))\n )\n\n try:\n pickler = NumpyPickler(filename, compress=compress,\n cache_size=cache_size, protocol=protocol)\n pickler.dump(value)\n pickler.close()\n finally:\n if 'pickler' in locals() and hasattr(pickler, 'file'):\n pickler.file.flush()\n pickler.file.close()\n return pickler._filenames\n\n\ndef load(filename, mmap_mode=None):\n \"\"\"Reconstruct a Python object from a file persisted with joblib.dump.\n\n Parameters\n -----------\n filename: string\n The name of the file from which to load the object\n mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional\n If not None, the arrays are memory-mapped from the disk. This\n mode has no effect for compressed files. Note that in this\n case the reconstructed object might not longer match exactly\n the originally pickled object.\n\n Returns\n -------\n result: any Python object\n The object stored in the file.\n\n See Also\n --------\n joblib.dump : function to save an object\n\n Notes\n -----\n\n This function can load numpy array files saved separately during the\n dump. If the mmap_mode argument is given, it is passed to np.load and\n arrays are loaded as memmaps. As a consequence, the reconstructed\n object might not match the original pickled object. Note that if the\n file was saved with compression, the arrays cannot be memmaped.\n \"\"\"\n with open(filename, 'rb') as file_handle:\n # We are careful to open the file handle early and keep it open to\n # avoid race-conditions on renames. That said, if data are stored in\n # companion files, moving the directory will create a race when\n # joblib tries to access the companion files.\n if _read_magic(file_handle) == _ZFILE_PREFIX:\n if mmap_mode is not None:\n warnings.warn('file \"%(filename)s\" appears to be a zip, '\n 'ignoring mmap_mode \"%(mmap_mode)s\" flag passed'\n % locals(), Warning, stacklevel=2)\n unpickler = ZipNumpyUnpickler(filename, file_handle=file_handle)\n else:\n unpickler = NumpyUnpickler(filename, file_handle=file_handle,\n mmap_mode=mmap_mode)\n\n try:\n obj = unpickler.load()\n except UnicodeDecodeError as exc:\n # More user-friendly error message\n if PY3_OR_LATER:\n new_exc = ValueError(\n 'You may be trying to read with '\n 'python 3 a joblib pickle generated with python 2. '\n 'This feature is not supported by joblib.')\n new_exc.__cause__ = exc\n raise new_exc\n finally:\n if hasattr(unpickler, 'file_handle'):\n unpickler.file_handle.close()\n return obj"},"implementation":{"kind":"string","value":"def read_zfile(file_handle):\n \"\"\"Read the z-file and return the content as a string\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guaranteed. Do not\n use for external purposes.\n \"\"\"\n file_handle.seek(0)\n assert _read_magic(file_handle) == _ZFILE_PREFIX, \\\n \"File does not have the right magic\"\n header_length = len(_ZFILE_PREFIX) + _MAX_LEN\n length = file_handle.read(header_length)\n length = length[len(_ZFILE_PREFIX):]\n length = int(length, 16)\n\n # With python2 and joblib version <= 0.8.4 compressed pickle header is one\n # character wider so we need to ignore an additional space if present.\n # Note: the first byte of the zlib data is guaranteed not to be a\n # space according to\n # https://tools.ietf.org/html/rfc6713#section-2.1\n next_byte = file_handle.read(1)\n if next_byte != b' ':\n # The zlib compressed data has started and we need to go back\n # one byte\n file_handle.seek(header_length)\n\n # We use the known length of the data to tell Zlib the size of the\n # buffer to allocate.\n data = zlib.decompress(file_handle.read(), 15, length)\n assert len(data) == length, (\n \"Incorrect data length while decompressing %s.\"\n \"The file could be corrupted.\" % file_handle)\n return data"},"start_line":{"kind":"number","value":61,"string":"61"},"end_line":{"kind":"number","value":93,"string":"93"},"file_content":{"kind":"string","value":"\"\"\"\nUtilities for fast persistence of big data, with optional compression.\n\"\"\"\n\n# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>\n# Copyright (c) 2009 Gael Varoquaux\n# License: BSD Style, 3 clauses.\n\nimport pickle\nimport traceback\nimport os\nimport zlib\nimport warnings\nfrom io import BytesIO\n\nfrom ._compat import _basestring, PY3_OR_LATER\n\n\nif PY3_OR_LATER:\n Unpickler = pickle._Unpickler\n Pickler = pickle._Pickler\n\n def asbytes(s):\n if isinstance(s, bytes):\n return s\n return s.encode('latin1')\nelse:\n Unpickler = pickle.Unpickler\n Pickler = pickle.Pickler\n asbytes = str\n\n\ndef hex_str(an_int):\n \"\"\"Converts an int to an hexadecimal string\n \"\"\"\n return '{0:#x}'.format(an_int)\n\n\n_MEGA = 2 ** 20\n\n# Compressed pickle header format: _ZFILE_PREFIX followed by _MAX_LEN\n# bytes which contains the length of the zlib compressed data as an\n# hexadecimal string. For example: 'ZF0x139 '\n_ZFILE_PREFIX = asbytes('ZF')\n_MAX_LEN = len(hex_str(2 ** 64))\n\n\n###############################################################################\n# Compressed file with Zlib\n\ndef _read_magic(file_handle):\n \"\"\" Utility to check the magic signature of a file identifying it as a\n Zfile\n \"\"\"\n magic = file_handle.read(len(_ZFILE_PREFIX))\n # Pickling needs file-handles at the beginning of the file\n file_handle.seek(0)\n return magic\n\n\ndef read_zfile(file_handle):\n \"\"\"Read the z-file and return the content as a string\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guaranteed. Do not\n use for external purposes.\n \"\"\"\n file_handle.seek(0)\n assert _read_magic(file_handle) == _ZFILE_PREFIX, \\\n \"File does not have the right magic\"\n header_length = len(_ZFILE_PREFIX) + _MAX_LEN\n length = file_handle.read(header_length)\n length = length[len(_ZFILE_PREFIX):]\n length = int(length, 16)\n\n # With python2 and joblib version <= 0.8.4 compressed pickle header is one\n # character wider so we need to ignore an additional space if present.\n # Note: the first byte of the zlib data is guaranteed not to be a\n # space according to\n # https://tools.ietf.org/html/rfc6713#section-2.1\n next_byte = file_handle.read(1)\n if next_byte != b' ':\n # The zlib compressed data has started and we need to go back\n # one byte\n file_handle.seek(header_length)\n\n # We use the known length of the data to tell Zlib the size of the\n # buffer to allocate.\n data = zlib.decompress(file_handle.read(), 15, length)\n assert len(data) == length, (\n \"Incorrect data length while decompressing %s.\"\n \"The file could be corrupted.\" % file_handle)\n return data\n\n\ndef write_zfile(file_handle, data, compress=1):\n \"\"\"Write the data in the given file as a Z-file.\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guarantied. Do not\n use for external purposes.\n \"\"\"\n file_handle.write(_ZFILE_PREFIX)\n length = hex_str(len(data))\n # Store the length of the data\n file_handle.write(asbytes(length.ljust(_MAX_LEN)))\n file_handle.write(zlib.compress(asbytes(data), compress))\n\n\n###############################################################################\n# Utility objects for persistence.\n\nclass NDArrayWrapper(object):\n \"\"\" An object to be persisted instead of numpy arrays.\n\n The only thing this object does, is to carry the filename in which\n the array has been persisted, and the array subclass.\n \"\"\"\n def __init__(self, filename, subclass, allow_mmap=True):\n \"Store the useful information for later\"\n self.filename = filename\n self.subclass = subclass\n self.allow_mmap = allow_mmap\n\n def read(self, unpickler):\n \"Reconstruct the array\"\n filename = os.path.join(unpickler._dirname, self.filename)\n # Load the array from the disk\n np_ver = [int(x) for x in unpickler.np.__version__.split('.', 2)[:2]]\n\n # use getattr instead of self.allow_mmap to ensure backward compat\n # with NDArrayWrapper instances pickled with joblib < 0.9.0\n allow_mmap = getattr(self, 'allow_mmap', True)\n memmap_kwargs = ({} if not allow_mmap\n else {'mmap_mode': unpickler.mmap_mode})\n array = unpickler.np.load(filename, **memmap_kwargs)\n # Reconstruct subclasses. This does not work with old\n # versions of numpy\n if (hasattr(array, '__array_prepare__')\n and not self.subclass in (unpickler.np.ndarray,\n unpickler.np.memmap)):\n # We need to reconstruct another subclass\n new_array = unpickler.np.core.multiarray._reconstruct(\n self.subclass, (0,), 'b')\n new_array.__array_prepare__(array)\n array = new_array\n return array\n\n #def __reduce__(self):\n # return None\n\n\nclass ZNDArrayWrapper(NDArrayWrapper):\n \"\"\"An object to be persisted instead of numpy arrays.\n\n This object store the Zfile filename in which\n the data array has been persisted, and the meta information to\n retrieve it.\n\n The reason that we store the raw buffer data of the array and\n the meta information, rather than array representation routine\n (tostring) is that it enables us to use completely the strided\n model to avoid memory copies (a and a.T store as fast). In\n addition saving the heavy information separately can avoid\n creating large temporary buffers when unpickling data with\n large arrays.\n \"\"\"\n def __init__(self, filename, init_args, state):\n \"Store the useful information for later\"\n self.filename = filename\n self.state = state\n self.init_args = init_args\n\n def read(self, unpickler):\n \"Reconstruct the array from the meta-information and the z-file\"\n # Here we a simply reproducing the unpickling mechanism for numpy\n # arrays\n filename = os.path.join(unpickler._dirname, self.filename)\n array = unpickler.np.core.multiarray._reconstruct(*self.init_args)\n with open(filename, 'rb') as f:\n data = read_zfile(f)\n state = self.state + (data,)\n array.__setstate__(state)\n return array\n\n\n###############################################################################\n# Pickler classes\n\nclass NumpyPickler(Pickler):\n \"\"\"A pickler to persist of big data efficiently.\n\n The main features of this object are:\n\n * persistence of numpy arrays in separate .npy files, for which\n I/O is fast.\n\n * optional compression using Zlib, with a special care on avoid\n temporaries.\n \"\"\"\n dispatch = Pickler.dispatch.copy()\n\n def __init__(self, filename, compress=0, cache_size=10, protocol=None):\n self._filename = filename\n self._filenames = [filename, ]\n self.cache_size = cache_size\n self.compress = compress\n if not self.compress:\n self.file = open(filename, 'wb')\n else:\n self.file = BytesIO()\n # Count the number of npy files that we have created:\n self._npy_counter = 1\n # By default we want a pickle protocol that only changes with\n # the major python version and not the minor one\n if protocol is None:\n protocol = (pickle.DEFAULT_PROTOCOL if PY3_OR_LATER\n else pickle.HIGHEST_PROTOCOL)\n\n Pickler.__init__(self, self.file,\n protocol=protocol)\n # delayed import of numpy, to avoid tight coupling\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _write_array(self, array, filename):\n if not self.compress:\n self.np.save(filename, array)\n allow_mmap = not array.dtype.hasobject\n container = NDArrayWrapper(os.path.basename(filename),\n type(array),\n allow_mmap=allow_mmap)\n else:\n filename += '.z'\n # Efficient compressed storage:\n # The meta data is stored in the container, and the core\n # numerics in a z-file\n _, init_args, state = array.__reduce__()\n # the last entry of 'state' is the data itself\n with open(filename, 'wb') as zfile:\n write_zfile(zfile, state[-1], compress=self.compress)\n state = state[:-1]\n container = ZNDArrayWrapper(os.path.basename(filename),\n init_args, state)\n return container, filename\n\n def save(self, obj):\n \"\"\" Subclass the save method, to save ndarray subclasses in npy\n files, rather than pickling them. Of course, this is a\n total abuse of the Pickler class.\n \"\"\"\n if (self.np is not None and type(obj) in\n (self.np.ndarray, self.np.matrix, self.np.memmap)):\n size = obj.size * obj.itemsize\n if self.compress and size < self.cache_size * _MEGA:\n # When compressing, as we are not writing directly to the\n # disk, it is more efficient to use standard pickling\n if type(obj) is self.np.memmap:\n # Pickling doesn't work with memmaped arrays\n obj = self.np.asarray(obj)\n return Pickler.save(self, obj)\n\n if not obj.dtype.hasobject:\n try:\n filename = '%s_%02i.npy' % (self._filename,\n self._npy_counter)\n # This converts the array in a container\n obj, filename = self._write_array(obj, filename)\n self._filenames.append(filename)\n self._npy_counter += 1\n except Exception:\n # XXX: We should have a logging mechanism\n print('Failed to save %s to .npy file:\\n%s' % (\n type(obj),\n traceback.format_exc()))\n\n return Pickler.save(self, obj)\n\n def close(self):\n if self.compress:\n with open(self._filename, 'wb') as zfile:\n write_zfile(zfile, self.file.getvalue(), self.compress)\n\n\nclass NumpyUnpickler(Unpickler):\n \"\"\"A subclass of the Unpickler to unpickle our numpy pickles.\n \"\"\"\n dispatch = Unpickler.dispatch.copy()\n\n def __init__(self, filename, file_handle, mmap_mode=None):\n self._filename = os.path.basename(filename)\n self._dirname = os.path.dirname(filename)\n self.mmap_mode = mmap_mode\n self.file_handle = self._open_pickle(file_handle)\n Unpickler.__init__(self, self.file_handle)\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _open_pickle(self, file_handle):\n return file_handle\n\n def load_build(self):\n \"\"\" This method is called to set the state of a newly created\n object.\n\n We capture it to replace our place-holder objects,\n NDArrayWrapper, by the array we are interested in. We\n replace them directly in the stack of pickler.\n \"\"\"\n Unpickler.load_build(self)\n if isinstance(self.stack[-1], NDArrayWrapper):\n if self.np is None:\n raise ImportError('Trying to unpickle an ndarray, '\n \"but numpy didn't import correctly\")\n nd_array_wrapper = self.stack.pop()\n array = nd_array_wrapper.read(self)\n self.stack.append(array)\n\n # Be careful to register our new method.\n if PY3_OR_LATER:\n dispatch[pickle.BUILD[0]] = load_build\n else:\n dispatch[pickle.BUILD] = load_build\n\n\nclass ZipNumpyUnpickler(NumpyUnpickler):\n \"\"\"A subclass of our Unpickler to unpickle on the fly from\n compressed storage.\"\"\"\n\n def __init__(self, filename, file_handle):\n NumpyUnpickler.__init__(self, filename,\n file_handle,\n mmap_mode=None)\n\n def _open_pickle(self, file_handle):\n return BytesIO(read_zfile(file_handle))\n\n\n###############################################################################\n# Utility functions\n\ndef dump(value, filename, compress=0, cache_size=100, protocol=None):\n \"\"\"Fast persistence of an arbitrary Python object into one or multiple\n files, with dedicated storage for numpy arrays.\n\n Parameters\n -----------\n value: any Python object\n The object to store to disk\n filename: string\n The name of the file in which it is to be stored\n compress: integer for 0 to 9, optional\n Optional compression level for the data. 0 is no compression.\n Higher means more compression, but also slower read and\n write times. Using a value of 3 is often a good compromise.\n See the notes for more details.\n cache_size: positive number, optional\n Fixes the order of magnitude (in megabytes) of the cache used\n for in-memory compression. Note that this is just an order of\n magnitude estimate and that for big arrays, the code will go\n over this value at dump and at load time.\n protocol: positive int\n Pickle protocol, see pickle.dump documentation for more details.\n\n Returns\n -------\n filenames: list of strings\n The list of file names in which the data is stored. If\n compress is false, each array is stored in a different file.\n\n See Also\n --------\n joblib.load : corresponding loader\n\n Notes\n -----\n Memmapping on load cannot be used for compressed files. Thus\n using compression can significantly slow down loading. In\n addition, compressed files take extra extra memory during\n dump and load.\n \"\"\"\n if compress is True:\n # By default, if compress is enabled, we want to be using 3 by\n # default\n compress = 3\n if not isinstance(filename, _basestring):\n # People keep inverting arguments, and the resulting error is\n # incomprehensible\n raise ValueError(\n 'Second argument should be a filename, %s (type %s) was given'\n % (filename, type(filename))\n )\n\n try:\n pickler = NumpyPickler(filename, compress=compress,\n cache_size=cache_size, protocol=protocol)\n pickler.dump(value)\n pickler.close()\n finally:\n if 'pickler' in locals() and hasattr(pickler, 'file'):\n pickler.file.flush()\n pickler.file.close()\n return pickler._filenames\n\n\ndef load(filename, mmap_mode=None):\n \"\"\"Reconstruct a Python object from a file persisted with joblib.dump.\n\n Parameters\n -----------\n filename: string\n The name of the file from which to load the object\n mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional\n If not None, the arrays are memory-mapped from the disk. This\n mode has no effect for compressed files. Note that in this\n case the reconstructed object might not longer match exactly\n the originally pickled object.\n\n Returns\n -------\n result: any Python object\n The object stored in the file.\n\n See Also\n --------\n joblib.dump : function to save an object\n\n Notes\n -----\n\n This function can load numpy array files saved separately during the\n dump. If the mmap_mode argument is given, it is passed to np.load and\n arrays are loaded as memmaps. As a consequence, the reconstructed\n object might not match the original pickled object. Note that if the\n file was saved with compression, the arrays cannot be memmaped.\n \"\"\"\n with open(filename, 'rb') as file_handle:\n # We are careful to open the file handle early and keep it open to\n # avoid race-conditions on renames. That said, if data are stored in\n # companion files, moving the directory will create a race when\n # joblib tries to access the companion files.\n if _read_magic(file_handle) == _ZFILE_PREFIX:\n if mmap_mode is not None:\n warnings.warn('file \"%(filename)s\" appears to be a zip, '\n 'ignoring mmap_mode \"%(mmap_mode)s\" flag passed'\n % locals(), Warning, stacklevel=2)\n unpickler = ZipNumpyUnpickler(filename, file_handle=file_handle)\n else:\n unpickler = NumpyUnpickler(filename, file_handle=file_handle,\n mmap_mode=mmap_mode)\n\n try:\n obj = unpickler.load()\n except UnicodeDecodeError as exc:\n # More user-friendly error message\n if PY3_OR_LATER:\n new_exc = ValueError(\n 'You may be trying to read with '\n 'python 3 a joblib pickle generated with python 2. '\n 'This feature is not supported by joblib.')\n new_exc.__cause__ = exc\n raise new_exc\n finally:\n if hasattr(unpickler, 'file_handle'):\n unpickler.file_handle.close()\n return obj\n"}}},{"rowIdx":2066,"cells":{"function_name":{"kind":"string","value":"write_zfile"},"docstring":{"kind":"string","value":"Write the data in the given file as a Z-file.\n\nZ-files are raw data compressed with zlib used internally by joblib\nfor persistence. Backward compatibility is not guarantied. Do not\nuse for external purposes."},"masked_code":{"kind":"string","value":"\"\"\"\nUtilities for fast persistence of big data, with optional compression.\n\"\"\"\n\n# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>\n# Copyright (c) 2009 Gael Varoquaux\n# License: BSD Style, 3 clauses.\n\nimport pickle\nimport traceback\nimport os\nimport zlib\nimport warnings\nfrom io import BytesIO\n\nfrom ._compat import _basestring, PY3_OR_LATER\n\n\nif PY3_OR_LATER:\n Unpickler = pickle._Unpickler\n Pickler = pickle._Pickler\n\n def asbytes(s):\n if isinstance(s, bytes):\n return s\n return s.encode('latin1')\nelse:\n Unpickler = pickle.Unpickler\n Pickler = pickle.Pickler\n asbytes = str\n\n\ndef hex_str(an_int):\n \"\"\"Converts an int to an hexadecimal string\n \"\"\"\n return '{0:#x}'.format(an_int)\n\n\n_MEGA = 2 ** 20\n\n# Compressed pickle header format: _ZFILE_PREFIX followed by _MAX_LEN\n# bytes which contains the length of the zlib compressed data as an\n# hexadecimal string. For example: 'ZF0x139 '\n_ZFILE_PREFIX = asbytes('ZF')\n_MAX_LEN = len(hex_str(2 ** 64))\n\n\n###############################################################################\n# Compressed file with Zlib\n\ndef _read_magic(file_handle):\n \"\"\" Utility to check the magic signature of a file identifying it as a\n Zfile\n \"\"\"\n magic = file_handle.read(len(_ZFILE_PREFIX))\n # Pickling needs file-handles at the beginning of the file\n file_handle.seek(0)\n return magic\n\n\ndef read_zfile(file_handle):\n \"\"\"Read the z-file and return the content as a string\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guaranteed. Do not\n use for external purposes.\n \"\"\"\n file_handle.seek(0)\n assert _read_magic(file_handle) == _ZFILE_PREFIX, \\\n \"File does not have the right magic\"\n header_length = len(_ZFILE_PREFIX) + _MAX_LEN\n length = file_handle.read(header_length)\n length = length[len(_ZFILE_PREFIX):]\n length = int(length, 16)\n\n # With python2 and joblib version <= 0.8.4 compressed pickle header is one\n # character wider so we need to ignore an additional space if present.\n # Note: the first byte of the zlib data is guaranteed not to be a\n # space according to\n # https://tools.ietf.org/html/rfc6713#section-2.1\n next_byte = file_handle.read(1)\n if next_byte != b' ':\n # The zlib compressed data has started and we need to go back\n # one byte\n file_handle.seek(header_length)\n\n # We use the known length of the data to tell Zlib the size of the\n # buffer to allocate.\n data = zlib.decompress(file_handle.read(), 15, length)\n assert len(data) == length, (\n \"Incorrect data length while decompressing %s.\"\n \"The file could be corrupted.\" % file_handle)\n return data\n\n\n# MASKED: write_zfile function (lines 96-107)\n\n\n###############################################################################\n# Utility objects for persistence.\n\nclass NDArrayWrapper(object):\n \"\"\" An object to be persisted instead of numpy arrays.\n\n The only thing this object does, is to carry the filename in which\n the array has been persisted, and the array subclass.\n \"\"\"\n def __init__(self, filename, subclass, allow_mmap=True):\n \"Store the useful information for later\"\n self.filename = filename\n self.subclass = subclass\n self.allow_mmap = allow_mmap\n\n def read(self, unpickler):\n \"Reconstruct the array\"\n filename = os.path.join(unpickler._dirname, self.filename)\n # Load the array from the disk\n np_ver = [int(x) for x in unpickler.np.__version__.split('.', 2)[:2]]\n\n # use getattr instead of self.allow_mmap to ensure backward compat\n # with NDArrayWrapper instances pickled with joblib < 0.9.0\n allow_mmap = getattr(self, 'allow_mmap', True)\n memmap_kwargs = ({} if not allow_mmap\n else {'mmap_mode': unpickler.mmap_mode})\n array = unpickler.np.load(filename, **memmap_kwargs)\n # Reconstruct subclasses. This does not work with old\n # versions of numpy\n if (hasattr(array, '__array_prepare__')\n and not self.subclass in (unpickler.np.ndarray,\n unpickler.np.memmap)):\n # We need to reconstruct another subclass\n new_array = unpickler.np.core.multiarray._reconstruct(\n self.subclass, (0,), 'b')\n new_array.__array_prepare__(array)\n array = new_array\n return array\n\n #def __reduce__(self):\n # return None\n\n\nclass ZNDArrayWrapper(NDArrayWrapper):\n \"\"\"An object to be persisted instead of numpy arrays.\n\n This object store the Zfile filename in which\n the data array has been persisted, and the meta information to\n retrieve it.\n\n The reason that we store the raw buffer data of the array and\n the meta information, rather than array representation routine\n (tostring) is that it enables us to use completely the strided\n model to avoid memory copies (a and a.T store as fast). In\n addition saving the heavy information separately can avoid\n creating large temporary buffers when unpickling data with\n large arrays.\n \"\"\"\n def __init__(self, filename, init_args, state):\n \"Store the useful information for later\"\n self.filename = filename\n self.state = state\n self.init_args = init_args\n\n def read(self, unpickler):\n \"Reconstruct the array from the meta-information and the z-file\"\n # Here we a simply reproducing the unpickling mechanism for numpy\n # arrays\n filename = os.path.join(unpickler._dirname, self.filename)\n array = unpickler.np.core.multiarray._reconstruct(*self.init_args)\n with open(filename, 'rb') as f:\n data = read_zfile(f)\n state = self.state + (data,)\n array.__setstate__(state)\n return array\n\n\n###############################################################################\n# Pickler classes\n\nclass NumpyPickler(Pickler):\n \"\"\"A pickler to persist of big data efficiently.\n\n The main features of this object are:\n\n * persistence of numpy arrays in separate .npy files, for which\n I/O is fast.\n\n * optional compression using Zlib, with a special care on avoid\n temporaries.\n \"\"\"\n dispatch = Pickler.dispatch.copy()\n\n def __init__(self, filename, compress=0, cache_size=10, protocol=None):\n self._filename = filename\n self._filenames = [filename, ]\n self.cache_size = cache_size\n self.compress = compress\n if not self.compress:\n self.file = open(filename, 'wb')\n else:\n self.file = BytesIO()\n # Count the number of npy files that we have created:\n self._npy_counter = 1\n # By default we want a pickle protocol that only changes with\n # the major python version and not the minor one\n if protocol is None:\n protocol = (pickle.DEFAULT_PROTOCOL if PY3_OR_LATER\n else pickle.HIGHEST_PROTOCOL)\n\n Pickler.__init__(self, self.file,\n protocol=protocol)\n # delayed import of numpy, to avoid tight coupling\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _write_array(self, array, filename):\n if not self.compress:\n self.np.save(filename, array)\n allow_mmap = not array.dtype.hasobject\n container = NDArrayWrapper(os.path.basename(filename),\n type(array),\n allow_mmap=allow_mmap)\n else:\n filename += '.z'\n # Efficient compressed storage:\n # The meta data is stored in the container, and the core\n # numerics in a z-file\n _, init_args, state = array.__reduce__()\n # the last entry of 'state' is the data itself\n with open(filename, 'wb') as zfile:\n write_zfile(zfile, state[-1], compress=self.compress)\n state = state[:-1]\n container = ZNDArrayWrapper(os.path.basename(filename),\n init_args, state)\n return container, filename\n\n def save(self, obj):\n \"\"\" Subclass the save method, to save ndarray subclasses in npy\n files, rather than pickling them. Of course, this is a\n total abuse of the Pickler class.\n \"\"\"\n if (self.np is not None and type(obj) in\n (self.np.ndarray, self.np.matrix, self.np.memmap)):\n size = obj.size * obj.itemsize\n if self.compress and size < self.cache_size * _MEGA:\n # When compressing, as we are not writing directly to the\n # disk, it is more efficient to use standard pickling\n if type(obj) is self.np.memmap:\n # Pickling doesn't work with memmaped arrays\n obj = self.np.asarray(obj)\n return Pickler.save(self, obj)\n\n if not obj.dtype.hasobject:\n try:\n filename = '%s_%02i.npy' % (self._filename,\n self._npy_counter)\n # This converts the array in a container\n obj, filename = self._write_array(obj, filename)\n self._filenames.append(filename)\n self._npy_counter += 1\n except Exception:\n # XXX: We should have a logging mechanism\n print('Failed to save %s to .npy file:\\n%s' % (\n type(obj),\n traceback.format_exc()))\n\n return Pickler.save(self, obj)\n\n def close(self):\n if self.compress:\n with open(self._filename, 'wb') as zfile:\n write_zfile(zfile, self.file.getvalue(), self.compress)\n\n\nclass NumpyUnpickler(Unpickler):\n \"\"\"A subclass of the Unpickler to unpickle our numpy pickles.\n \"\"\"\n dispatch = Unpickler.dispatch.copy()\n\n def __init__(self, filename, file_handle, mmap_mode=None):\n self._filename = os.path.basename(filename)\n self._dirname = os.path.dirname(filename)\n self.mmap_mode = mmap_mode\n self.file_handle = self._open_pickle(file_handle)\n Unpickler.__init__(self, self.file_handle)\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _open_pickle(self, file_handle):\n return file_handle\n\n def load_build(self):\n \"\"\" This method is called to set the state of a newly created\n object.\n\n We capture it to replace our place-holder objects,\n NDArrayWrapper, by the array we are interested in. We\n replace them directly in the stack of pickler.\n \"\"\"\n Unpickler.load_build(self)\n if isinstance(self.stack[-1], NDArrayWrapper):\n if self.np is None:\n raise ImportError('Trying to unpickle an ndarray, '\n \"but numpy didn't import correctly\")\n nd_array_wrapper = self.stack.pop()\n array = nd_array_wrapper.read(self)\n self.stack.append(array)\n\n # Be careful to register our new method.\n if PY3_OR_LATER:\n dispatch[pickle.BUILD[0]] = load_build\n else:\n dispatch[pickle.BUILD] = load_build\n\n\nclass ZipNumpyUnpickler(NumpyUnpickler):\n \"\"\"A subclass of our Unpickler to unpickle on the fly from\n compressed storage.\"\"\"\n\n def __init__(self, filename, file_handle):\n NumpyUnpickler.__init__(self, filename,\n file_handle,\n mmap_mode=None)\n\n def _open_pickle(self, file_handle):\n return BytesIO(read_zfile(file_handle))\n\n\n###############################################################################\n# Utility functions\n\ndef dump(value, filename, compress=0, cache_size=100, protocol=None):\n \"\"\"Fast persistence of an arbitrary Python object into one or multiple\n files, with dedicated storage for numpy arrays.\n\n Parameters\n -----------\n value: any Python object\n The object to store to disk\n filename: string\n The name of the file in which it is to be stored\n compress: integer for 0 to 9, optional\n Optional compression level for the data. 0 is no compression.\n Higher means more compression, but also slower read and\n write times. Using a value of 3 is often a good compromise.\n See the notes for more details.\n cache_size: positive number, optional\n Fixes the order of magnitude (in megabytes) of the cache used\n for in-memory compression. Note that this is just an order of\n magnitude estimate and that for big arrays, the code will go\n over this value at dump and at load time.\n protocol: positive int\n Pickle protocol, see pickle.dump documentation for more details.\n\n Returns\n -------\n filenames: list of strings\n The list of file names in which the data is stored. If\n compress is false, each array is stored in a different file.\n\n See Also\n --------\n joblib.load : corresponding loader\n\n Notes\n -----\n Memmapping on load cannot be used for compressed files. Thus\n using compression can significantly slow down loading. In\n addition, compressed files take extra extra memory during\n dump and load.\n \"\"\"\n if compress is True:\n # By default, if compress is enabled, we want to be using 3 by\n # default\n compress = 3\n if not isinstance(filename, _basestring):\n # People keep inverting arguments, and the resulting error is\n # incomprehensible\n raise ValueError(\n 'Second argument should be a filename, %s (type %s) was given'\n % (filename, type(filename))\n )\n\n try:\n pickler = NumpyPickler(filename, compress=compress,\n cache_size=cache_size, protocol=protocol)\n pickler.dump(value)\n pickler.close()\n finally:\n if 'pickler' in locals() and hasattr(pickler, 'file'):\n pickler.file.flush()\n pickler.file.close()\n return pickler._filenames\n\n\ndef load(filename, mmap_mode=None):\n \"\"\"Reconstruct a Python object from a file persisted with joblib.dump.\n\n Parameters\n -----------\n filename: string\n The name of the file from which to load the object\n mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional\n If not None, the arrays are memory-mapped from the disk. This\n mode has no effect for compressed files. Note that in this\n case the reconstructed object might not longer match exactly\n the originally pickled object.\n\n Returns\n -------\n result: any Python object\n The object stored in the file.\n\n See Also\n --------\n joblib.dump : function to save an object\n\n Notes\n -----\n\n This function can load numpy array files saved separately during the\n dump. If the mmap_mode argument is given, it is passed to np.load and\n arrays are loaded as memmaps. As a consequence, the reconstructed\n object might not match the original pickled object. Note that if the\n file was saved with compression, the arrays cannot be memmaped.\n \"\"\"\n with open(filename, 'rb') as file_handle:\n # We are careful to open the file handle early and keep it open to\n # avoid race-conditions on renames. That said, if data are stored in\n # companion files, moving the directory will create a race when\n # joblib tries to access the companion files.\n if _read_magic(file_handle) == _ZFILE_PREFIX:\n if mmap_mode is not None:\n warnings.warn('file \"%(filename)s\" appears to be a zip, '\n 'ignoring mmap_mode \"%(mmap_mode)s\" flag passed'\n % locals(), Warning, stacklevel=2)\n unpickler = ZipNumpyUnpickler(filename, file_handle=file_handle)\n else:\n unpickler = NumpyUnpickler(filename, file_handle=file_handle,\n mmap_mode=mmap_mode)\n\n try:\n obj = unpickler.load()\n except UnicodeDecodeError as exc:\n # More user-friendly error message\n if PY3_OR_LATER:\n new_exc = ValueError(\n 'You may be trying to read with '\n 'python 3 a joblib pickle generated with python 2. '\n 'This feature is not supported by joblib.')\n new_exc.__cause__ = exc\n raise new_exc\n finally:\n if hasattr(unpickler, 'file_handle'):\n unpickler.file_handle.close()\n return obj"},"implementation":{"kind":"string","value":"def write_zfile(file_handle, data, compress=1):\n \"\"\"Write the data in the given file as a Z-file.\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guarantied. Do not\n use for external purposes.\n \"\"\"\n file_handle.write(_ZFILE_PREFIX)\n length = hex_str(len(data))\n # Store the length of the data\n file_handle.write(asbytes(length.ljust(_MAX_LEN)))\n file_handle.write(zlib.compress(asbytes(data), compress))"},"start_line":{"kind":"number","value":96,"string":"96"},"end_line":{"kind":"number","value":107,"string":"107"},"file_content":{"kind":"string","value":"\"\"\"\nUtilities for fast persistence of big data, with optional compression.\n\"\"\"\n\n# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>\n# Copyright (c) 2009 Gael Varoquaux\n# License: BSD Style, 3 clauses.\n\nimport pickle\nimport traceback\nimport os\nimport zlib\nimport warnings\nfrom io import BytesIO\n\nfrom ._compat import _basestring, PY3_OR_LATER\n\n\nif PY3_OR_LATER:\n Unpickler = pickle._Unpickler\n Pickler = pickle._Pickler\n\n def asbytes(s):\n if isinstance(s, bytes):\n return s\n return s.encode('latin1')\nelse:\n Unpickler = pickle.Unpickler\n Pickler = pickle.Pickler\n asbytes = str\n\n\ndef hex_str(an_int):\n \"\"\"Converts an int to an hexadecimal string\n \"\"\"\n return '{0:#x}'.format(an_int)\n\n\n_MEGA = 2 ** 20\n\n# Compressed pickle header format: _ZFILE_PREFIX followed by _MAX_LEN\n# bytes which contains the length of the zlib compressed data as an\n# hexadecimal string. For example: 'ZF0x139 '\n_ZFILE_PREFIX = asbytes('ZF')\n_MAX_LEN = len(hex_str(2 ** 64))\n\n\n###############################################################################\n# Compressed file with Zlib\n\ndef _read_magic(file_handle):\n \"\"\" Utility to check the magic signature of a file identifying it as a\n Zfile\n \"\"\"\n magic = file_handle.read(len(_ZFILE_PREFIX))\n # Pickling needs file-handles at the beginning of the file\n file_handle.seek(0)\n return magic\n\n\ndef read_zfile(file_handle):\n \"\"\"Read the z-file and return the content as a string\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guaranteed. Do not\n use for external purposes.\n \"\"\"\n file_handle.seek(0)\n assert _read_magic(file_handle) == _ZFILE_PREFIX, \\\n \"File does not have the right magic\"\n header_length = len(_ZFILE_PREFIX) + _MAX_LEN\n length = file_handle.read(header_length)\n length = length[len(_ZFILE_PREFIX):]\n length = int(length, 16)\n\n # With python2 and joblib version <= 0.8.4 compressed pickle header is one\n # character wider so we need to ignore an additional space if present.\n # Note: the first byte of the zlib data is guaranteed not to be a\n # space according to\n # https://tools.ietf.org/html/rfc6713#section-2.1\n next_byte = file_handle.read(1)\n if next_byte != b' ':\n # The zlib compressed data has started and we need to go back\n # one byte\n file_handle.seek(header_length)\n\n # We use the known length of the data to tell Zlib the size of the\n # buffer to allocate.\n data = zlib.decompress(file_handle.read(), 15, length)\n assert len(data) == length, (\n \"Incorrect data length while decompressing %s.\"\n \"The file could be corrupted.\" % file_handle)\n return data\n\n\ndef write_zfile(file_handle, data, compress=1):\n \"\"\"Write the data in the given file as a Z-file.\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guarantied. Do not\n use for external purposes.\n \"\"\"\n file_handle.write(_ZFILE_PREFIX)\n length = hex_str(len(data))\n # Store the length of the data\n file_handle.write(asbytes(length.ljust(_MAX_LEN)))\n file_handle.write(zlib.compress(asbytes(data), compress))\n\n\n###############################################################################\n# Utility objects for persistence.\n\nclass NDArrayWrapper(object):\n \"\"\" An object to be persisted instead of numpy arrays.\n\n The only thing this object does, is to carry the filename in which\n the array has been persisted, and the array subclass.\n \"\"\"\n def __init__(self, filename, subclass, allow_mmap=True):\n \"Store the useful information for later\"\n self.filename = filename\n self.subclass = subclass\n self.allow_mmap = allow_mmap\n\n def read(self, unpickler):\n \"Reconstruct the array\"\n filename = os.path.join(unpickler._dirname, self.filename)\n # Load the array from the disk\n np_ver = [int(x) for x in unpickler.np.__version__.split('.', 2)[:2]]\n\n # use getattr instead of self.allow_mmap to ensure backward compat\n # with NDArrayWrapper instances pickled with joblib < 0.9.0\n allow_mmap = getattr(self, 'allow_mmap', True)\n memmap_kwargs = ({} if not allow_mmap\n else {'mmap_mode': unpickler.mmap_mode})\n array = unpickler.np.load(filename, **memmap_kwargs)\n # Reconstruct subclasses. This does not work with old\n # versions of numpy\n if (hasattr(array, '__array_prepare__')\n and not self.subclass in (unpickler.np.ndarray,\n unpickler.np.memmap)):\n # We need to reconstruct another subclass\n new_array = unpickler.np.core.multiarray._reconstruct(\n self.subclass, (0,), 'b')\n new_array.__array_prepare__(array)\n array = new_array\n return array\n\n #def __reduce__(self):\n # return None\n\n\nclass ZNDArrayWrapper(NDArrayWrapper):\n \"\"\"An object to be persisted instead of numpy arrays.\n\n This object store the Zfile filename in which\n the data array has been persisted, and the meta information to\n retrieve it.\n\n The reason that we store the raw buffer data of the array and\n the meta information, rather than array representation routine\n (tostring) is that it enables us to use completely the strided\n model to avoid memory copies (a and a.T store as fast). In\n addition saving the heavy information separately can avoid\n creating large temporary buffers when unpickling data with\n large arrays.\n \"\"\"\n def __init__(self, filename, init_args, state):\n \"Store the useful information for later\"\n self.filename = filename\n self.state = state\n self.init_args = init_args\n\n def read(self, unpickler):\n \"Reconstruct the array from the meta-information and the z-file\"\n # Here we a simply reproducing the unpickling mechanism for numpy\n # arrays\n filename = os.path.join(unpickler._dirname, self.filename)\n array = unpickler.np.core.multiarray._reconstruct(*self.init_args)\n with open(filename, 'rb') as f:\n data = read_zfile(f)\n state = self.state + (data,)\n array.__setstate__(state)\n return array\n\n\n###############################################################################\n# Pickler classes\n\nclass NumpyPickler(Pickler):\n \"\"\"A pickler to persist of big data efficiently.\n\n The main features of this object are:\n\n * persistence of numpy arrays in separate .npy files, for which\n I/O is fast.\n\n * optional compression using Zlib, with a special care on avoid\n temporaries.\n \"\"\"\n dispatch = Pickler.dispatch.copy()\n\n def __init__(self, filename, compress=0, cache_size=10, protocol=None):\n self._filename = filename\n self._filenames = [filename, ]\n self.cache_size = cache_size\n self.compress = compress\n if not self.compress:\n self.file = open(filename, 'wb')\n else:\n self.file = BytesIO()\n # Count the number of npy files that we have created:\n self._npy_counter = 1\n # By default we want a pickle protocol that only changes with\n # the major python version and not the minor one\n if protocol is None:\n protocol = (pickle.DEFAULT_PROTOCOL if PY3_OR_LATER\n else pickle.HIGHEST_PROTOCOL)\n\n Pickler.__init__(self, self.file,\n protocol=protocol)\n # delayed import of numpy, to avoid tight coupling\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _write_array(self, array, filename):\n if not self.compress:\n self.np.save(filename, array)\n allow_mmap = not array.dtype.hasobject\n container = NDArrayWrapper(os.path.basename(filename),\n type(array),\n allow_mmap=allow_mmap)\n else:\n filename += '.z'\n # Efficient compressed storage:\n # The meta data is stored in the container, and the core\n # numerics in a z-file\n _, init_args, state = array.__reduce__()\n # the last entry of 'state' is the data itself\n with open(filename, 'wb') as zfile:\n write_zfile(zfile, state[-1], compress=self.compress)\n state = state[:-1]\n container = ZNDArrayWrapper(os.path.basename(filename),\n init_args, state)\n return container, filename\n\n def save(self, obj):\n \"\"\" Subclass the save method, to save ndarray subclasses in npy\n files, rather than pickling them. Of course, this is a\n total abuse of the Pickler class.\n \"\"\"\n if (self.np is not None and type(obj) in\n (self.np.ndarray, self.np.matrix, self.np.memmap)):\n size = obj.size * obj.itemsize\n if self.compress and size < self.cache_size * _MEGA:\n # When compressing, as we are not writing directly to the\n # disk, it is more efficient to use standard pickling\n if type(obj) is self.np.memmap:\n # Pickling doesn't work with memmaped arrays\n obj = self.np.asarray(obj)\n return Pickler.save(self, obj)\n\n if not obj.dtype.hasobject:\n try:\n filename = '%s_%02i.npy' % (self._filename,\n self._npy_counter)\n # This converts the array in a container\n obj, filename = self._write_array(obj, filename)\n self._filenames.append(filename)\n self._npy_counter += 1\n except Exception:\n # XXX: We should have a logging mechanism\n print('Failed to save %s to .npy file:\\n%s' % (\n type(obj),\n traceback.format_exc()))\n\n return Pickler.save(self, obj)\n\n def close(self):\n if self.compress:\n with open(self._filename, 'wb') as zfile:\n write_zfile(zfile, self.file.getvalue(), self.compress)\n\n\nclass NumpyUnpickler(Unpickler):\n \"\"\"A subclass of the Unpickler to unpickle our numpy pickles.\n \"\"\"\n dispatch = Unpickler.dispatch.copy()\n\n def __init__(self, filename, file_handle, mmap_mode=None):\n self._filename = os.path.basename(filename)\n self._dirname = os.path.dirname(filename)\n self.mmap_mode = mmap_mode\n self.file_handle = self._open_pickle(file_handle)\n Unpickler.__init__(self, self.file_handle)\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _open_pickle(self, file_handle):\n return file_handle\n\n def load_build(self):\n \"\"\" This method is called to set the state of a newly created\n object.\n\n We capture it to replace our place-holder objects,\n NDArrayWrapper, by the array we are interested in. We\n replace them directly in the stack of pickler.\n \"\"\"\n Unpickler.load_build(self)\n if isinstance(self.stack[-1], NDArrayWrapper):\n if self.np is None:\n raise ImportError('Trying to unpickle an ndarray, '\n \"but numpy didn't import correctly\")\n nd_array_wrapper = self.stack.pop()\n array = nd_array_wrapper.read(self)\n self.stack.append(array)\n\n # Be careful to register our new method.\n if PY3_OR_LATER:\n dispatch[pickle.BUILD[0]] = load_build\n else:\n dispatch[pickle.BUILD] = load_build\n\n\nclass ZipNumpyUnpickler(NumpyUnpickler):\n \"\"\"A subclass of our Unpickler to unpickle on the fly from\n compressed storage.\"\"\"\n\n def __init__(self, filename, file_handle):\n NumpyUnpickler.__init__(self, filename,\n file_handle,\n mmap_mode=None)\n\n def _open_pickle(self, file_handle):\n return BytesIO(read_zfile(file_handle))\n\n\n###############################################################################\n# Utility functions\n\ndef dump(value, filename, compress=0, cache_size=100, protocol=None):\n \"\"\"Fast persistence of an arbitrary Python object into one or multiple\n files, with dedicated storage for numpy arrays.\n\n Parameters\n -----------\n value: any Python object\n The object to store to disk\n filename: string\n The name of the file in which it is to be stored\n compress: integer for 0 to 9, optional\n Optional compression level for the data. 0 is no compression.\n Higher means more compression, but also slower read and\n write times. Using a value of 3 is often a good compromise.\n See the notes for more details.\n cache_size: positive number, optional\n Fixes the order of magnitude (in megabytes) of the cache used\n for in-memory compression. Note that this is just an order of\n magnitude estimate and that for big arrays, the code will go\n over this value at dump and at load time.\n protocol: positive int\n Pickle protocol, see pickle.dump documentation for more details.\n\n Returns\n -------\n filenames: list of strings\n The list of file names in which the data is stored. If\n compress is false, each array is stored in a different file.\n\n See Also\n --------\n joblib.load : corresponding loader\n\n Notes\n -----\n Memmapping on load cannot be used for compressed files. Thus\n using compression can significantly slow down loading. In\n addition, compressed files take extra extra memory during\n dump and load.\n \"\"\"\n if compress is True:\n # By default, if compress is enabled, we want to be using 3 by\n # default\n compress = 3\n if not isinstance(filename, _basestring):\n # People keep inverting arguments, and the resulting error is\n # incomprehensible\n raise ValueError(\n 'Second argument should be a filename, %s (type %s) was given'\n % (filename, type(filename))\n )\n\n try:\n pickler = NumpyPickler(filename, compress=compress,\n cache_size=cache_size, protocol=protocol)\n pickler.dump(value)\n pickler.close()\n finally:\n if 'pickler' in locals() and hasattr(pickler, 'file'):\n pickler.file.flush()\n pickler.file.close()\n return pickler._filenames\n\n\ndef load(filename, mmap_mode=None):\n \"\"\"Reconstruct a Python object from a file persisted with joblib.dump.\n\n Parameters\n -----------\n filename: string\n The name of the file from which to load the object\n mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional\n If not None, the arrays are memory-mapped from the disk. This\n mode has no effect for compressed files. Note that in this\n case the reconstructed object might not longer match exactly\n the originally pickled object.\n\n Returns\n -------\n result: any Python object\n The object stored in the file.\n\n See Also\n --------\n joblib.dump : function to save an object\n\n Notes\n -----\n\n This function can load numpy array files saved separately during the\n dump. If the mmap_mode argument is given, it is passed to np.load and\n arrays are loaded as memmaps. As a consequence, the reconstructed\n object might not match the original pickled object. Note that if the\n file was saved with compression, the arrays cannot be memmaped.\n \"\"\"\n with open(filename, 'rb') as file_handle:\n # We are careful to open the file handle early and keep it open to\n # avoid race-conditions on renames. That said, if data are stored in\n # companion files, moving the directory will create a race when\n # joblib tries to access the companion files.\n if _read_magic(file_handle) == _ZFILE_PREFIX:\n if mmap_mode is not None:\n warnings.warn('file \"%(filename)s\" appears to be a zip, '\n 'ignoring mmap_mode \"%(mmap_mode)s\" flag passed'\n % locals(), Warning, stacklevel=2)\n unpickler = ZipNumpyUnpickler(filename, file_handle=file_handle)\n else:\n unpickler = NumpyUnpickler(filename, file_handle=file_handle,\n mmap_mode=mmap_mode)\n\n try:\n obj = unpickler.load()\n except UnicodeDecodeError as exc:\n # More user-friendly error message\n if PY3_OR_LATER:\n new_exc = ValueError(\n 'You may be trying to read with '\n 'python 3 a joblib pickle generated with python 2. '\n 'This feature is not supported by joblib.')\n new_exc.__cause__ = exc\n raise new_exc\n finally:\n if hasattr(unpickler, 'file_handle'):\n unpickler.file_handle.close()\n return obj\n"}}},{"rowIdx":2067,"cells":{"function_name":{"kind":"string","value":"dump"},"docstring":{"kind":"string","value":"Fast persistence of an arbitrary Python object into one or multiple\nfiles, with dedicated storage for numpy arrays.\n\nParameters\n-----------\nvalue: any Python object\n The object to store to disk\nfilename: string\n The name of the file in which it is to be stored\ncompress: integer for 0 to 9, optional\n Optional compression level for the data. 0 is no compression.\n Higher means more compression, but also slower read and\n write times. Using a value of 3 is often a good compromise.\n See the notes for more details.\ncache_size: positive number, optional\n Fixes the order of magnitude (in megabytes) of the cache used\n for in-memory compression. Note that this is just an order of\n magnitude estimate and that for big arrays, the code will go\n over this value at dump and at load time.\nprotocol: positive int\n Pickle protocol, see pickle.dump documentation for more details.\n\nReturns\n-------\nfilenames: list of strings\n The list of file names in which the data is stored. If\n compress is false, each array is stored in a different file.\n\nSee Also\n--------\njoblib.load : corresponding loader\n\nNotes\n-----\nMemmapping on load cannot be used for compressed files. Thus\nusing compression can significantly slow down loading. In\naddition, compressed files take extra extra memory during\ndump and load."},"masked_code":{"kind":"string","value":"\"\"\"\nUtilities for fast persistence of big data, with optional compression.\n\"\"\"\n\n# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>\n# Copyright (c) 2009 Gael Varoquaux\n# License: BSD Style, 3 clauses.\n\nimport pickle\nimport traceback\nimport os\nimport zlib\nimport warnings\nfrom io import BytesIO\n\nfrom ._compat import _basestring, PY3_OR_LATER\n\n\nif PY3_OR_LATER:\n Unpickler = pickle._Unpickler\n Pickler = pickle._Pickler\n\n def asbytes(s):\n if isinstance(s, bytes):\n return s\n return s.encode('latin1')\nelse:\n Unpickler = pickle.Unpickler\n Pickler = pickle.Pickler\n asbytes = str\n\n\ndef hex_str(an_int):\n \"\"\"Converts an int to an hexadecimal string\n \"\"\"\n return '{0:#x}'.format(an_int)\n\n\n_MEGA = 2 ** 20\n\n# Compressed pickle header format: _ZFILE_PREFIX followed by _MAX_LEN\n# bytes which contains the length of the zlib compressed data as an\n# hexadecimal string. For example: 'ZF0x139 '\n_ZFILE_PREFIX = asbytes('ZF')\n_MAX_LEN = len(hex_str(2 ** 64))\n\n\n###############################################################################\n# Compressed file with Zlib\n\ndef _read_magic(file_handle):\n \"\"\" Utility to check the magic signature of a file identifying it as a\n Zfile\n \"\"\"\n magic = file_handle.read(len(_ZFILE_PREFIX))\n # Pickling needs file-handles at the beginning of the file\n file_handle.seek(0)\n return magic\n\n\ndef read_zfile(file_handle):\n \"\"\"Read the z-file and return the content as a string\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guaranteed. Do not\n use for external purposes.\n \"\"\"\n file_handle.seek(0)\n assert _read_magic(file_handle) == _ZFILE_PREFIX, \\\n \"File does not have the right magic\"\n header_length = len(_ZFILE_PREFIX) + _MAX_LEN\n length = file_handle.read(header_length)\n length = length[len(_ZFILE_PREFIX):]\n length = int(length, 16)\n\n # With python2 and joblib version <= 0.8.4 compressed pickle header is one\n # character wider so we need to ignore an additional space if present.\n # Note: the first byte of the zlib data is guaranteed not to be a\n # space according to\n # https://tools.ietf.org/html/rfc6713#section-2.1\n next_byte = file_handle.read(1)\n if next_byte != b' ':\n # The zlib compressed data has started and we need to go back\n # one byte\n file_handle.seek(header_length)\n\n # We use the known length of the data to tell Zlib the size of the\n # buffer to allocate.\n data = zlib.decompress(file_handle.read(), 15, length)\n assert len(data) == length, (\n \"Incorrect data length while decompressing %s.\"\n \"The file could be corrupted.\" % file_handle)\n return data\n\n\ndef write_zfile(file_handle, data, compress=1):\n \"\"\"Write the data in the given file as a Z-file.\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guarantied. Do not\n use for external purposes.\n \"\"\"\n file_handle.write(_ZFILE_PREFIX)\n length = hex_str(len(data))\n # Store the length of the data\n file_handle.write(asbytes(length.ljust(_MAX_LEN)))\n file_handle.write(zlib.compress(asbytes(data), compress))\n\n\n###############################################################################\n# Utility objects for persistence.\n\nclass NDArrayWrapper(object):\n \"\"\" An object to be persisted instead of numpy arrays.\n\n The only thing this object does, is to carry the filename in which\n the array has been persisted, and the array subclass.\n \"\"\"\n def __init__(self, filename, subclass, allow_mmap=True):\n \"Store the useful information for later\"\n self.filename = filename\n self.subclass = subclass\n self.allow_mmap = allow_mmap\n\n def read(self, unpickler):\n \"Reconstruct the array\"\n filename = os.path.join(unpickler._dirname, self.filename)\n # Load the array from the disk\n np_ver = [int(x) for x in unpickler.np.__version__.split('.', 2)[:2]]\n\n # use getattr instead of self.allow_mmap to ensure backward compat\n # with NDArrayWrapper instances pickled with joblib < 0.9.0\n allow_mmap = getattr(self, 'allow_mmap', True)\n memmap_kwargs = ({} if not allow_mmap\n else {'mmap_mode': unpickler.mmap_mode})\n array = unpickler.np.load(filename, **memmap_kwargs)\n # Reconstruct subclasses. This does not work with old\n # versions of numpy\n if (hasattr(array, '__array_prepare__')\n and not self.subclass in (unpickler.np.ndarray,\n unpickler.np.memmap)):\n # We need to reconstruct another subclass\n new_array = unpickler.np.core.multiarray._reconstruct(\n self.subclass, (0,), 'b')\n new_array.__array_prepare__(array)\n array = new_array\n return array\n\n #def __reduce__(self):\n # return None\n\n\nclass ZNDArrayWrapper(NDArrayWrapper):\n \"\"\"An object to be persisted instead of numpy arrays.\n\n This object store the Zfile filename in which\n the data array has been persisted, and the meta information to\n retrieve it.\n\n The reason that we store the raw buffer data of the array and\n the meta information, rather than array representation routine\n (tostring) is that it enables us to use completely the strided\n model to avoid memory copies (a and a.T store as fast). In\n addition saving the heavy information separately can avoid\n creating large temporary buffers when unpickling data with\n large arrays.\n \"\"\"\n def __init__(self, filename, init_args, state):\n \"Store the useful information for later\"\n self.filename = filename\n self.state = state\n self.init_args = init_args\n\n def read(self, unpickler):\n \"Reconstruct the array from the meta-information and the z-file\"\n # Here we a simply reproducing the unpickling mechanism for numpy\n # arrays\n filename = os.path.join(unpickler._dirname, self.filename)\n array = unpickler.np.core.multiarray._reconstruct(*self.init_args)\n with open(filename, 'rb') as f:\n data = read_zfile(f)\n state = self.state + (data,)\n array.__setstate__(state)\n return array\n\n\n###############################################################################\n# Pickler classes\n\nclass NumpyPickler(Pickler):\n \"\"\"A pickler to persist of big data efficiently.\n\n The main features of this object are:\n\n * persistence of numpy arrays in separate .npy files, for which\n I/O is fast.\n\n * optional compression using Zlib, with a special care on avoid\n temporaries.\n \"\"\"\n dispatch = Pickler.dispatch.copy()\n\n def __init__(self, filename, compress=0, cache_size=10, protocol=None):\n self._filename = filename\n self._filenames = [filename, ]\n self.cache_size = cache_size\n self.compress = compress\n if not self.compress:\n self.file = open(filename, 'wb')\n else:\n self.file = BytesIO()\n # Count the number of npy files that we have created:\n self._npy_counter = 1\n # By default we want a pickle protocol that only changes with\n # the major python version and not the minor one\n if protocol is None:\n protocol = (pickle.DEFAULT_PROTOCOL if PY3_OR_LATER\n else pickle.HIGHEST_PROTOCOL)\n\n Pickler.__init__(self, self.file,\n protocol=protocol)\n # delayed import of numpy, to avoid tight coupling\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _write_array(self, array, filename):\n if not self.compress:\n self.np.save(filename, array)\n allow_mmap = not array.dtype.hasobject\n container = NDArrayWrapper(os.path.basename(filename),\n type(array),\n allow_mmap=allow_mmap)\n else:\n filename += '.z'\n # Efficient compressed storage:\n # The meta data is stored in the container, and the core\n # numerics in a z-file\n _, init_args, state = array.__reduce__()\n # the last entry of 'state' is the data itself\n with open(filename, 'wb') as zfile:\n write_zfile(zfile, state[-1], compress=self.compress)\n state = state[:-1]\n container = ZNDArrayWrapper(os.path.basename(filename),\n init_args, state)\n return container, filename\n\n def save(self, obj):\n \"\"\" Subclass the save method, to save ndarray subclasses in npy\n files, rather than pickling them. Of course, this is a\n total abuse of the Pickler class.\n \"\"\"\n if (self.np is not None and type(obj) in\n (self.np.ndarray, self.np.matrix, self.np.memmap)):\n size = obj.size * obj.itemsize\n if self.compress and size < self.cache_size * _MEGA:\n # When compressing, as we are not writing directly to the\n # disk, it is more efficient to use standard pickling\n if type(obj) is self.np.memmap:\n # Pickling doesn't work with memmaped arrays\n obj = self.np.asarray(obj)\n return Pickler.save(self, obj)\n\n if not obj.dtype.hasobject:\n try:\n filename = '%s_%02i.npy' % (self._filename,\n self._npy_counter)\n # This converts the array in a container\n obj, filename = self._write_array(obj, filename)\n self._filenames.append(filename)\n self._npy_counter += 1\n except Exception:\n # XXX: We should have a logging mechanism\n print('Failed to save %s to .npy file:\\n%s' % (\n type(obj),\n traceback.format_exc()))\n\n return Pickler.save(self, obj)\n\n def close(self):\n if self.compress:\n with open(self._filename, 'wb') as zfile:\n write_zfile(zfile, self.file.getvalue(), self.compress)\n\n\nclass NumpyUnpickler(Unpickler):\n \"\"\"A subclass of the Unpickler to unpickle our numpy pickles.\n \"\"\"\n dispatch = Unpickler.dispatch.copy()\n\n def __init__(self, filename, file_handle, mmap_mode=None):\n self._filename = os.path.basename(filename)\n self._dirname = os.path.dirname(filename)\n self.mmap_mode = mmap_mode\n self.file_handle = self._open_pickle(file_handle)\n Unpickler.__init__(self, self.file_handle)\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _open_pickle(self, file_handle):\n return file_handle\n\n def load_build(self):\n \"\"\" This method is called to set the state of a newly created\n object.\n\n We capture it to replace our place-holder objects,\n NDArrayWrapper, by the array we are interested in. We\n replace them directly in the stack of pickler.\n \"\"\"\n Unpickler.load_build(self)\n if isinstance(self.stack[-1], NDArrayWrapper):\n if self.np is None:\n raise ImportError('Trying to unpickle an ndarray, '\n \"but numpy didn't import correctly\")\n nd_array_wrapper = self.stack.pop()\n array = nd_array_wrapper.read(self)\n self.stack.append(array)\n\n # Be careful to register our new method.\n if PY3_OR_LATER:\n dispatch[pickle.BUILD[0]] = load_build\n else:\n dispatch[pickle.BUILD] = load_build\n\n\nclass ZipNumpyUnpickler(NumpyUnpickler):\n \"\"\"A subclass of our Unpickler to unpickle on the fly from\n compressed storage.\"\"\"\n\n def __init__(self, filename, file_handle):\n NumpyUnpickler.__init__(self, filename,\n file_handle,\n mmap_mode=None)\n\n def _open_pickle(self, file_handle):\n return BytesIO(read_zfile(file_handle))\n\n\n###############################################################################\n# Utility functions\n\n# MASKED: dump function (lines 348-409)\n\n\ndef load(filename, mmap_mode=None):\n \"\"\"Reconstruct a Python object from a file persisted with joblib.dump.\n\n Parameters\n -----------\n filename: string\n The name of the file from which to load the object\n mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional\n If not None, the arrays are memory-mapped from the disk. This\n mode has no effect for compressed files. Note that in this\n case the reconstructed object might not longer match exactly\n the originally pickled object.\n\n Returns\n -------\n result: any Python object\n The object stored in the file.\n\n See Also\n --------\n joblib.dump : function to save an object\n\n Notes\n -----\n\n This function can load numpy array files saved separately during the\n dump. If the mmap_mode argument is given, it is passed to np.load and\n arrays are loaded as memmaps. As a consequence, the reconstructed\n object might not match the original pickled object. Note that if the\n file was saved with compression, the arrays cannot be memmaped.\n \"\"\"\n with open(filename, 'rb') as file_handle:\n # We are careful to open the file handle early and keep it open to\n # avoid race-conditions on renames. That said, if data are stored in\n # companion files, moving the directory will create a race when\n # joblib tries to access the companion files.\n if _read_magic(file_handle) == _ZFILE_PREFIX:\n if mmap_mode is not None:\n warnings.warn('file \"%(filename)s\" appears to be a zip, '\n 'ignoring mmap_mode \"%(mmap_mode)s\" flag passed'\n % locals(), Warning, stacklevel=2)\n unpickler = ZipNumpyUnpickler(filename, file_handle=file_handle)\n else:\n unpickler = NumpyUnpickler(filename, file_handle=file_handle,\n mmap_mode=mmap_mode)\n\n try:\n obj = unpickler.load()\n except UnicodeDecodeError as exc:\n # More user-friendly error message\n if PY3_OR_LATER:\n new_exc = ValueError(\n 'You may be trying to read with '\n 'python 3 a joblib pickle generated with python 2. '\n 'This feature is not supported by joblib.')\n new_exc.__cause__ = exc\n raise new_exc\n finally:\n if hasattr(unpickler, 'file_handle'):\n unpickler.file_handle.close()\n return obj"},"implementation":{"kind":"string","value":"def dump(value, filename, compress=0, cache_size=100, protocol=None):\n \"\"\"Fast persistence of an arbitrary Python object into one or multiple\n files, with dedicated storage for numpy arrays.\n\n Parameters\n -----------\n value: any Python object\n The object to store to disk\n filename: string\n The name of the file in which it is to be stored\n compress: integer for 0 to 9, optional\n Optional compression level for the data. 0 is no compression.\n Higher means more compression, but also slower read and\n write times. Using a value of 3 is often a good compromise.\n See the notes for more details.\n cache_size: positive number, optional\n Fixes the order of magnitude (in megabytes) of the cache used\n for in-memory compression. Note that this is just an order of\n magnitude estimate and that for big arrays, the code will go\n over this value at dump and at load time.\n protocol: positive int\n Pickle protocol, see pickle.dump documentation for more details.\n\n Returns\n -------\n filenames: list of strings\n The list of file names in which the data is stored. If\n compress is false, each array is stored in a different file.\n\n See Also\n --------\n joblib.load : corresponding loader\n\n Notes\n -----\n Memmapping on load cannot be used for compressed files. Thus\n using compression can significantly slow down loading. In\n addition, compressed files take extra extra memory during\n dump and load.\n \"\"\"\n if compress is True:\n # By default, if compress is enabled, we want to be using 3 by\n # default\n compress = 3\n if not isinstance(filename, _basestring):\n # People keep inverting arguments, and the resulting error is\n # incomprehensible\n raise ValueError(\n 'Second argument should be a filename, %s (type %s) was given'\n % (filename, type(filename))\n )\n\n try:\n pickler = NumpyPickler(filename, compress=compress,\n cache_size=cache_size, protocol=protocol)\n pickler.dump(value)\n pickler.close()\n finally:\n if 'pickler' in locals() and hasattr(pickler, 'file'):\n pickler.file.flush()\n pickler.file.close()\n return pickler._filenames"},"start_line":{"kind":"number","value":348,"string":"348"},"end_line":{"kind":"number","value":409,"string":"409"},"file_content":{"kind":"string","value":"\"\"\"\nUtilities for fast persistence of big data, with optional compression.\n\"\"\"\n\n# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>\n# Copyright (c) 2009 Gael Varoquaux\n# License: BSD Style, 3 clauses.\n\nimport pickle\nimport traceback\nimport os\nimport zlib\nimport warnings\nfrom io import BytesIO\n\nfrom ._compat import _basestring, PY3_OR_LATER\n\n\nif PY3_OR_LATER:\n Unpickler = pickle._Unpickler\n Pickler = pickle._Pickler\n\n def asbytes(s):\n if isinstance(s, bytes):\n return s\n return s.encode('latin1')\nelse:\n Unpickler = pickle.Unpickler\n Pickler = pickle.Pickler\n asbytes = str\n\n\ndef hex_str(an_int):\n \"\"\"Converts an int to an hexadecimal string\n \"\"\"\n return '{0:#x}'.format(an_int)\n\n\n_MEGA = 2 ** 20\n\n# Compressed pickle header format: _ZFILE_PREFIX followed by _MAX_LEN\n# bytes which contains the length of the zlib compressed data as an\n# hexadecimal string. For example: 'ZF0x139 '\n_ZFILE_PREFIX = asbytes('ZF')\n_MAX_LEN = len(hex_str(2 ** 64))\n\n\n###############################################################################\n# Compressed file with Zlib\n\ndef _read_magic(file_handle):\n \"\"\" Utility to check the magic signature of a file identifying it as a\n Zfile\n \"\"\"\n magic = file_handle.read(len(_ZFILE_PREFIX))\n # Pickling needs file-handles at the beginning of the file\n file_handle.seek(0)\n return magic\n\n\ndef read_zfile(file_handle):\n \"\"\"Read the z-file and return the content as a string\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guaranteed. Do not\n use for external purposes.\n \"\"\"\n file_handle.seek(0)\n assert _read_magic(file_handle) == _ZFILE_PREFIX, \\\n \"File does not have the right magic\"\n header_length = len(_ZFILE_PREFIX) + _MAX_LEN\n length = file_handle.read(header_length)\n length = length[len(_ZFILE_PREFIX):]\n length = int(length, 16)\n\n # With python2 and joblib version <= 0.8.4 compressed pickle header is one\n # character wider so we need to ignore an additional space if present.\n # Note: the first byte of the zlib data is guaranteed not to be a\n # space according to\n # https://tools.ietf.org/html/rfc6713#section-2.1\n next_byte = file_handle.read(1)\n if next_byte != b' ':\n # The zlib compressed data has started and we need to go back\n # one byte\n file_handle.seek(header_length)\n\n # We use the known length of the data to tell Zlib the size of the\n # buffer to allocate.\n data = zlib.decompress(file_handle.read(), 15, length)\n assert len(data) == length, (\n \"Incorrect data length while decompressing %s.\"\n \"The file could be corrupted.\" % file_handle)\n return data\n\n\ndef write_zfile(file_handle, data, compress=1):\n \"\"\"Write the data in the given file as a Z-file.\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guarantied. Do not\n use for external purposes.\n \"\"\"\n file_handle.write(_ZFILE_PREFIX)\n length = hex_str(len(data))\n # Store the length of the data\n file_handle.write(asbytes(length.ljust(_MAX_LEN)))\n file_handle.write(zlib.compress(asbytes(data), compress))\n\n\n###############################################################################\n# Utility objects for persistence.\n\nclass NDArrayWrapper(object):\n \"\"\" An object to be persisted instead of numpy arrays.\n\n The only thing this object does, is to carry the filename in which\n the array has been persisted, and the array subclass.\n \"\"\"\n def __init__(self, filename, subclass, allow_mmap=True):\n \"Store the useful information for later\"\n self.filename = filename\n self.subclass = subclass\n self.allow_mmap = allow_mmap\n\n def read(self, unpickler):\n \"Reconstruct the array\"\n filename = os.path.join(unpickler._dirname, self.filename)\n # Load the array from the disk\n np_ver = [int(x) for x in unpickler.np.__version__.split('.', 2)[:2]]\n\n # use getattr instead of self.allow_mmap to ensure backward compat\n # with NDArrayWrapper instances pickled with joblib < 0.9.0\n allow_mmap = getattr(self, 'allow_mmap', True)\n memmap_kwargs = ({} if not allow_mmap\n else {'mmap_mode': unpickler.mmap_mode})\n array = unpickler.np.load(filename, **memmap_kwargs)\n # Reconstruct subclasses. This does not work with old\n # versions of numpy\n if (hasattr(array, '__array_prepare__')\n and not self.subclass in (unpickler.np.ndarray,\n unpickler.np.memmap)):\n # We need to reconstruct another subclass\n new_array = unpickler.np.core.multiarray._reconstruct(\n self.subclass, (0,), 'b')\n new_array.__array_prepare__(array)\n array = new_array\n return array\n\n #def __reduce__(self):\n # return None\n\n\nclass ZNDArrayWrapper(NDArrayWrapper):\n \"\"\"An object to be persisted instead of numpy arrays.\n\n This object store the Zfile filename in which\n the data array has been persisted, and the meta information to\n retrieve it.\n\n The reason that we store the raw buffer data of the array and\n the meta information, rather than array representation routine\n (tostring) is that it enables us to use completely the strided\n model to avoid memory copies (a and a.T store as fast). In\n addition saving the heavy information separately can avoid\n creating large temporary buffers when unpickling data with\n large arrays.\n \"\"\"\n def __init__(self, filename, init_args, state):\n \"Store the useful information for later\"\n self.filename = filename\n self.state = state\n self.init_args = init_args\n\n def read(self, unpickler):\n \"Reconstruct the array from the meta-information and the z-file\"\n # Here we a simply reproducing the unpickling mechanism for numpy\n # arrays\n filename = os.path.join(unpickler._dirname, self.filename)\n array = unpickler.np.core.multiarray._reconstruct(*self.init_args)\n with open(filename, 'rb') as f:\n data = read_zfile(f)\n state = self.state + (data,)\n array.__setstate__(state)\n return array\n\n\n###############################################################################\n# Pickler classes\n\nclass NumpyPickler(Pickler):\n \"\"\"A pickler to persist of big data efficiently.\n\n The main features of this object are:\n\n * persistence of numpy arrays in separate .npy files, for which\n I/O is fast.\n\n * optional compression using Zlib, with a special care on avoid\n temporaries.\n \"\"\"\n dispatch = Pickler.dispatch.copy()\n\n def __init__(self, filename, compress=0, cache_size=10, protocol=None):\n self._filename = filename\n self._filenames = [filename, ]\n self.cache_size = cache_size\n self.compress = compress\n if not self.compress:\n self.file = open(filename, 'wb')\n else:\n self.file = BytesIO()\n # Count the number of npy files that we have created:\n self._npy_counter = 1\n # By default we want a pickle protocol that only changes with\n # the major python version and not the minor one\n if protocol is None:\n protocol = (pickle.DEFAULT_PROTOCOL if PY3_OR_LATER\n else pickle.HIGHEST_PROTOCOL)\n\n Pickler.__init__(self, self.file,\n protocol=protocol)\n # delayed import of numpy, to avoid tight coupling\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _write_array(self, array, filename):\n if not self.compress:\n self.np.save(filename, array)\n allow_mmap = not array.dtype.hasobject\n container = NDArrayWrapper(os.path.basename(filename),\n type(array),\n allow_mmap=allow_mmap)\n else:\n filename += '.z'\n # Efficient compressed storage:\n # The meta data is stored in the container, and the core\n # numerics in a z-file\n _, init_args, state = array.__reduce__()\n # the last entry of 'state' is the data itself\n with open(filename, 'wb') as zfile:\n write_zfile(zfile, state[-1], compress=self.compress)\n state = state[:-1]\n container = ZNDArrayWrapper(os.path.basename(filename),\n init_args, state)\n return container, filename\n\n def save(self, obj):\n \"\"\" Subclass the save method, to save ndarray subclasses in npy\n files, rather than pickling them. Of course, this is a\n total abuse of the Pickler class.\n \"\"\"\n if (self.np is not None and type(obj) in\n (self.np.ndarray, self.np.matrix, self.np.memmap)):\n size = obj.size * obj.itemsize\n if self.compress and size < self.cache_size * _MEGA:\n # When compressing, as we are not writing directly to the\n # disk, it is more efficient to use standard pickling\n if type(obj) is self.np.memmap:\n # Pickling doesn't work with memmaped arrays\n obj = self.np.asarray(obj)\n return Pickler.save(self, obj)\n\n if not obj.dtype.hasobject:\n try:\n filename = '%s_%02i.npy' % (self._filename,\n self._npy_counter)\n # This converts the array in a container\n obj, filename = self._write_array(obj, filename)\n self._filenames.append(filename)\n self._npy_counter += 1\n except Exception:\n # XXX: We should have a logging mechanism\n print('Failed to save %s to .npy file:\\n%s' % (\n type(obj),\n traceback.format_exc()))\n\n return Pickler.save(self, obj)\n\n def close(self):\n if self.compress:\n with open(self._filename, 'wb') as zfile:\n write_zfile(zfile, self.file.getvalue(), self.compress)\n\n\nclass NumpyUnpickler(Unpickler):\n \"\"\"A subclass of the Unpickler to unpickle our numpy pickles.\n \"\"\"\n dispatch = Unpickler.dispatch.copy()\n\n def __init__(self, filename, file_handle, mmap_mode=None):\n self._filename = os.path.basename(filename)\n self._dirname = os.path.dirname(filename)\n self.mmap_mode = mmap_mode\n self.file_handle = self._open_pickle(file_handle)\n Unpickler.__init__(self, self.file_handle)\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _open_pickle(self, file_handle):\n return file_handle\n\n def load_build(self):\n \"\"\" This method is called to set the state of a newly created\n object.\n\n We capture it to replace our place-holder objects,\n NDArrayWrapper, by the array we are interested in. We\n replace them directly in the stack of pickler.\n \"\"\"\n Unpickler.load_build(self)\n if isinstance(self.stack[-1], NDArrayWrapper):\n if self.np is None:\n raise ImportError('Trying to unpickle an ndarray, '\n \"but numpy didn't import correctly\")\n nd_array_wrapper = self.stack.pop()\n array = nd_array_wrapper.read(self)\n self.stack.append(array)\n\n # Be careful to register our new method.\n if PY3_OR_LATER:\n dispatch[pickle.BUILD[0]] = load_build\n else:\n dispatch[pickle.BUILD] = load_build\n\n\nclass ZipNumpyUnpickler(NumpyUnpickler):\n \"\"\"A subclass of our Unpickler to unpickle on the fly from\n compressed storage.\"\"\"\n\n def __init__(self, filename, file_handle):\n NumpyUnpickler.__init__(self, filename,\n file_handle,\n mmap_mode=None)\n\n def _open_pickle(self, file_handle):\n return BytesIO(read_zfile(file_handle))\n\n\n###############################################################################\n# Utility functions\n\ndef dump(value, filename, compress=0, cache_size=100, protocol=None):\n \"\"\"Fast persistence of an arbitrary Python object into one or multiple\n files, with dedicated storage for numpy arrays.\n\n Parameters\n -----------\n value: any Python object\n The object to store to disk\n filename: string\n The name of the file in which it is to be stored\n compress: integer for 0 to 9, optional\n Optional compression level for the data. 0 is no compression.\n Higher means more compression, but also slower read and\n write times. Using a value of 3 is often a good compromise.\n See the notes for more details.\n cache_size: positive number, optional\n Fixes the order of magnitude (in megabytes) of the cache used\n for in-memory compression. Note that this is just an order of\n magnitude estimate and that for big arrays, the code will go\n over this value at dump and at load time.\n protocol: positive int\n Pickle protocol, see pickle.dump documentation for more details.\n\n Returns\n -------\n filenames: list of strings\n The list of file names in which the data is stored. If\n compress is false, each array is stored in a different file.\n\n See Also\n --------\n joblib.load : corresponding loader\n\n Notes\n -----\n Memmapping on load cannot be used for compressed files. Thus\n using compression can significantly slow down loading. In\n addition, compressed files take extra extra memory during\n dump and load.\n \"\"\"\n if compress is True:\n # By default, if compress is enabled, we want to be using 3 by\n # default\n compress = 3\n if not isinstance(filename, _basestring):\n # People keep inverting arguments, and the resulting error is\n # incomprehensible\n raise ValueError(\n 'Second argument should be a filename, %s (type %s) was given'\n % (filename, type(filename))\n )\n\n try:\n pickler = NumpyPickler(filename, compress=compress,\n cache_size=cache_size, protocol=protocol)\n pickler.dump(value)\n pickler.close()\n finally:\n if 'pickler' in locals() and hasattr(pickler, 'file'):\n pickler.file.flush()\n pickler.file.close()\n return pickler._filenames\n\n\ndef load(filename, mmap_mode=None):\n \"\"\"Reconstruct a Python object from a file persisted with joblib.dump.\n\n Parameters\n -----------\n filename: string\n The name of the file from which to load the object\n mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional\n If not None, the arrays are memory-mapped from the disk. This\n mode has no effect for compressed files. Note that in this\n case the reconstructed object might not longer match exactly\n the originally pickled object.\n\n Returns\n -------\n result: any Python object\n The object stored in the file.\n\n See Also\n --------\n joblib.dump : function to save an object\n\n Notes\n -----\n\n This function can load numpy array files saved separately during the\n dump. If the mmap_mode argument is given, it is passed to np.load and\n arrays are loaded as memmaps. As a consequence, the reconstructed\n object might not match the original pickled object. Note that if the\n file was saved with compression, the arrays cannot be memmaped.\n \"\"\"\n with open(filename, 'rb') as file_handle:\n # We are careful to open the file handle early and keep it open to\n # avoid race-conditions on renames. That said, if data are stored in\n # companion files, moving the directory will create a race when\n # joblib tries to access the companion files.\n if _read_magic(file_handle) == _ZFILE_PREFIX:\n if mmap_mode is not None:\n warnings.warn('file \"%(filename)s\" appears to be a zip, '\n 'ignoring mmap_mode \"%(mmap_mode)s\" flag passed'\n % locals(), Warning, stacklevel=2)\n unpickler = ZipNumpyUnpickler(filename, file_handle=file_handle)\n else:\n unpickler = NumpyUnpickler(filename, file_handle=file_handle,\n mmap_mode=mmap_mode)\n\n try:\n obj = unpickler.load()\n except UnicodeDecodeError as exc:\n # More user-friendly error message\n if PY3_OR_LATER:\n new_exc = ValueError(\n 'You may be trying to read with '\n 'python 3 a joblib pickle generated with python 2. '\n 'This feature is not supported by joblib.')\n new_exc.__cause__ = exc\n raise new_exc\n finally:\n if hasattr(unpickler, 'file_handle'):\n unpickler.file_handle.close()\n return obj\n"}}},{"rowIdx":2068,"cells":{"function_name":{"kind":"string","value":"load_build"},"docstring":{"kind":"string","value":"This method is called to set the state of a newly created\nobject.\n\nWe capture it to replace our place-holder objects,\nNDArrayWrapper, by the array we are interested in. We\nreplace them directly in the stack of pickler."},"masked_code":{"kind":"string","value":"\"\"\"\nUtilities for fast persistence of big data, with optional compression.\n\"\"\"\n\n# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>\n# Copyright (c) 2009 Gael Varoquaux\n# License: BSD Style, 3 clauses.\n\nimport pickle\nimport traceback\nimport os\nimport zlib\nimport warnings\nfrom io import BytesIO\n\nfrom ._compat import _basestring, PY3_OR_LATER\n\n\nif PY3_OR_LATER:\n Unpickler = pickle._Unpickler\n Pickler = pickle._Pickler\n\n def asbytes(s):\n if isinstance(s, bytes):\n return s\n return s.encode('latin1')\nelse:\n Unpickler = pickle.Unpickler\n Pickler = pickle.Pickler\n asbytes = str\n\n\ndef hex_str(an_int):\n \"\"\"Converts an int to an hexadecimal string\n \"\"\"\n return '{0:#x}'.format(an_int)\n\n\n_MEGA = 2 ** 20\n\n# Compressed pickle header format: _ZFILE_PREFIX followed by _MAX_LEN\n# bytes which contains the length of the zlib compressed data as an\n# hexadecimal string. For example: 'ZF0x139 '\n_ZFILE_PREFIX = asbytes('ZF')\n_MAX_LEN = len(hex_str(2 ** 64))\n\n\n###############################################################################\n# Compressed file with Zlib\n\ndef _read_magic(file_handle):\n \"\"\" Utility to check the magic signature of a file identifying it as a\n Zfile\n \"\"\"\n magic = file_handle.read(len(_ZFILE_PREFIX))\n # Pickling needs file-handles at the beginning of the file\n file_handle.seek(0)\n return magic\n\n\ndef read_zfile(file_handle):\n \"\"\"Read the z-file and return the content as a string\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guaranteed. Do not\n use for external purposes.\n \"\"\"\n file_handle.seek(0)\n assert _read_magic(file_handle) == _ZFILE_PREFIX, \\\n \"File does not have the right magic\"\n header_length = len(_ZFILE_PREFIX) + _MAX_LEN\n length = file_handle.read(header_length)\n length = length[len(_ZFILE_PREFIX):]\n length = int(length, 16)\n\n # With python2 and joblib version <= 0.8.4 compressed pickle header is one\n # character wider so we need to ignore an additional space if present.\n # Note: the first byte of the zlib data is guaranteed not to be a\n # space according to\n # https://tools.ietf.org/html/rfc6713#section-2.1\n next_byte = file_handle.read(1)\n if next_byte != b' ':\n # The zlib compressed data has started and we need to go back\n # one byte\n file_handle.seek(header_length)\n\n # We use the known length of the data to tell Zlib the size of the\n # buffer to allocate.\n data = zlib.decompress(file_handle.read(), 15, length)\n assert len(data) == length, (\n \"Incorrect data length while decompressing %s.\"\n \"The file could be corrupted.\" % file_handle)\n return data\n\n\ndef write_zfile(file_handle, data, compress=1):\n \"\"\"Write the data in the given file as a Z-file.\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guarantied. Do not\n use for external purposes.\n \"\"\"\n file_handle.write(_ZFILE_PREFIX)\n length = hex_str(len(data))\n # Store the length of the data\n file_handle.write(asbytes(length.ljust(_MAX_LEN)))\n file_handle.write(zlib.compress(asbytes(data), compress))\n\n\n###############################################################################\n# Utility objects for persistence.\n\nclass NDArrayWrapper(object):\n \"\"\" An object to be persisted instead of numpy arrays.\n\n The only thing this object does, is to carry the filename in which\n the array has been persisted, and the array subclass.\n \"\"\"\n def __init__(self, filename, subclass, allow_mmap=True):\n \"Store the useful information for later\"\n self.filename = filename\n self.subclass = subclass\n self.allow_mmap = allow_mmap\n\n def read(self, unpickler):\n \"Reconstruct the array\"\n filename = os.path.join(unpickler._dirname, self.filename)\n # Load the array from the disk\n np_ver = [int(x) for x in unpickler.np.__version__.split('.', 2)[:2]]\n\n # use getattr instead of self.allow_mmap to ensure backward compat\n # with NDArrayWrapper instances pickled with joblib < 0.9.0\n allow_mmap = getattr(self, 'allow_mmap', True)\n memmap_kwargs = ({} if not allow_mmap\n else {'mmap_mode': unpickler.mmap_mode})\n array = unpickler.np.load(filename, **memmap_kwargs)\n # Reconstruct subclasses. This does not work with old\n # versions of numpy\n if (hasattr(array, '__array_prepare__')\n and not self.subclass in (unpickler.np.ndarray,\n unpickler.np.memmap)):\n # We need to reconstruct another subclass\n new_array = unpickler.np.core.multiarray._reconstruct(\n self.subclass, (0,), 'b')\n new_array.__array_prepare__(array)\n array = new_array\n return array\n\n #def __reduce__(self):\n # return None\n\n\nclass ZNDArrayWrapper(NDArrayWrapper):\n \"\"\"An object to be persisted instead of numpy arrays.\n\n This object store the Zfile filename in which\n the data array has been persisted, and the meta information to\n retrieve it.\n\n The reason that we store the raw buffer data of the array and\n the meta information, rather than array representation routine\n (tostring) is that it enables us to use completely the strided\n model to avoid memory copies (a and a.T store as fast). In\n addition saving the heavy information separately can avoid\n creating large temporary buffers when unpickling data with\n large arrays.\n \"\"\"\n def __init__(self, filename, init_args, state):\n \"Store the useful information for later\"\n self.filename = filename\n self.state = state\n self.init_args = init_args\n\n def read(self, unpickler):\n \"Reconstruct the array from the meta-information and the z-file\"\n # Here we a simply reproducing the unpickling mechanism for numpy\n # arrays\n filename = os.path.join(unpickler._dirname, self.filename)\n array = unpickler.np.core.multiarray._reconstruct(*self.init_args)\n with open(filename, 'rb') as f:\n data = read_zfile(f)\n state = self.state + (data,)\n array.__setstate__(state)\n return array\n\n\n###############################################################################\n# Pickler classes\n\nclass NumpyPickler(Pickler):\n \"\"\"A pickler to persist of big data efficiently.\n\n The main features of this object are:\n\n * persistence of numpy arrays in separate .npy files, for which\n I/O is fast.\n\n * optional compression using Zlib, with a special care on avoid\n temporaries.\n \"\"\"\n dispatch = Pickler.dispatch.copy()\n\n def __init__(self, filename, compress=0, cache_size=10, protocol=None):\n self._filename = filename\n self._filenames = [filename, ]\n self.cache_size = cache_size\n self.compress = compress\n if not self.compress:\n self.file = open(filename, 'wb')\n else:\n self.file = BytesIO()\n # Count the number of npy files that we have created:\n self._npy_counter = 1\n # By default we want a pickle protocol that only changes with\n # the major python version and not the minor one\n if protocol is None:\n protocol = (pickle.DEFAULT_PROTOCOL if PY3_OR_LATER\n else pickle.HIGHEST_PROTOCOL)\n\n Pickler.__init__(self, self.file,\n protocol=protocol)\n # delayed import of numpy, to avoid tight coupling\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _write_array(self, array, filename):\n if not self.compress:\n self.np.save(filename, array)\n allow_mmap = not array.dtype.hasobject\n container = NDArrayWrapper(os.path.basename(filename),\n type(array),\n allow_mmap=allow_mmap)\n else:\n filename += '.z'\n # Efficient compressed storage:\n # The meta data is stored in the container, and the core\n # numerics in a z-file\n _, init_args, state = array.__reduce__()\n # the last entry of 'state' is the data itself\n with open(filename, 'wb') as zfile:\n write_zfile(zfile, state[-1], compress=self.compress)\n state = state[:-1]\n container = ZNDArrayWrapper(os.path.basename(filename),\n init_args, state)\n return container, filename\n\n def save(self, obj):\n \"\"\" Subclass the save method, to save ndarray subclasses in npy\n files, rather than pickling them. Of course, this is a\n total abuse of the Pickler class.\n \"\"\"\n if (self.np is not None and type(obj) in\n (self.np.ndarray, self.np.matrix, self.np.memmap)):\n size = obj.size * obj.itemsize\n if self.compress and size < self.cache_size * _MEGA:\n # When compressing, as we are not writing directly to the\n # disk, it is more efficient to use standard pickling\n if type(obj) is self.np.memmap:\n # Pickling doesn't work with memmaped arrays\n obj = self.np.asarray(obj)\n return Pickler.save(self, obj)\n\n if not obj.dtype.hasobject:\n try:\n filename = '%s_%02i.npy' % (self._filename,\n self._npy_counter)\n # This converts the array in a container\n obj, filename = self._write_array(obj, filename)\n self._filenames.append(filename)\n self._npy_counter += 1\n except Exception:\n # XXX: We should have a logging mechanism\n print('Failed to save %s to .npy file:\\n%s' % (\n type(obj),\n traceback.format_exc()))\n\n return Pickler.save(self, obj)\n\n def close(self):\n if self.compress:\n with open(self._filename, 'wb') as zfile:\n write_zfile(zfile, self.file.getvalue(), self.compress)\n\n\nclass NumpyUnpickler(Unpickler):\n \"\"\"A subclass of the Unpickler to unpickle our numpy pickles.\n \"\"\"\n dispatch = Unpickler.dispatch.copy()\n\n def __init__(self, filename, file_handle, mmap_mode=None):\n self._filename = os.path.basename(filename)\n self._dirname = os.path.dirname(filename)\n self.mmap_mode = mmap_mode\n self.file_handle = self._open_pickle(file_handle)\n Unpickler.__init__(self, self.file_handle)\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _open_pickle(self, file_handle):\n return file_handle\n\n# MASKED: load_build function (lines 308-323)\n\n # Be careful to register our new method.\n if PY3_OR_LATER:\n dispatch[pickle.BUILD[0]] = load_build\n else:\n dispatch[pickle.BUILD] = load_build\n\n\nclass ZipNumpyUnpickler(NumpyUnpickler):\n \"\"\"A subclass of our Unpickler to unpickle on the fly from\n compressed storage.\"\"\"\n\n def __init__(self, filename, file_handle):\n NumpyUnpickler.__init__(self, filename,\n file_handle,\n mmap_mode=None)\n\n def _open_pickle(self, file_handle):\n return BytesIO(read_zfile(file_handle))\n\n\n###############################################################################\n# Utility functions\n\ndef dump(value, filename, compress=0, cache_size=100, protocol=None):\n \"\"\"Fast persistence of an arbitrary Python object into one or multiple\n files, with dedicated storage for numpy arrays.\n\n Parameters\n -----------\n value: any Python object\n The object to store to disk\n filename: string\n The name of the file in which it is to be stored\n compress: integer for 0 to 9, optional\n Optional compression level for the data. 0 is no compression.\n Higher means more compression, but also slower read and\n write times. Using a value of 3 is often a good compromise.\n See the notes for more details.\n cache_size: positive number, optional\n Fixes the order of magnitude (in megabytes) of the cache used\n for in-memory compression. Note that this is just an order of\n magnitude estimate and that for big arrays, the code will go\n over this value at dump and at load time.\n protocol: positive int\n Pickle protocol, see pickle.dump documentation for more details.\n\n Returns\n -------\n filenames: list of strings\n The list of file names in which the data is stored. If\n compress is false, each array is stored in a different file.\n\n See Also\n --------\n joblib.load : corresponding loader\n\n Notes\n -----\n Memmapping on load cannot be used for compressed files. Thus\n using compression can significantly slow down loading. In\n addition, compressed files take extra extra memory during\n dump and load.\n \"\"\"\n if compress is True:\n # By default, if compress is enabled, we want to be using 3 by\n # default\n compress = 3\n if not isinstance(filename, _basestring):\n # People keep inverting arguments, and the resulting error is\n # incomprehensible\n raise ValueError(\n 'Second argument should be a filename, %s (type %s) was given'\n % (filename, type(filename))\n )\n\n try:\n pickler = NumpyPickler(filename, compress=compress,\n cache_size=cache_size, protocol=protocol)\n pickler.dump(value)\n pickler.close()\n finally:\n if 'pickler' in locals() and hasattr(pickler, 'file'):\n pickler.file.flush()\n pickler.file.close()\n return pickler._filenames\n\n\ndef load(filename, mmap_mode=None):\n \"\"\"Reconstruct a Python object from a file persisted with joblib.dump.\n\n Parameters\n -----------\n filename: string\n The name of the file from which to load the object\n mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional\n If not None, the arrays are memory-mapped from the disk. This\n mode has no effect for compressed files. Note that in this\n case the reconstructed object might not longer match exactly\n the originally pickled object.\n\n Returns\n -------\n result: any Python object\n The object stored in the file.\n\n See Also\n --------\n joblib.dump : function to save an object\n\n Notes\n -----\n\n This function can load numpy array files saved separately during the\n dump. If the mmap_mode argument is given, it is passed to np.load and\n arrays are loaded as memmaps. As a consequence, the reconstructed\n object might not match the original pickled object. Note that if the\n file was saved with compression, the arrays cannot be memmaped.\n \"\"\"\n with open(filename, 'rb') as file_handle:\n # We are careful to open the file handle early and keep it open to\n # avoid race-conditions on renames. That said, if data are stored in\n # companion files, moving the directory will create a race when\n # joblib tries to access the companion files.\n if _read_magic(file_handle) == _ZFILE_PREFIX:\n if mmap_mode is not None:\n warnings.warn('file \"%(filename)s\" appears to be a zip, '\n 'ignoring mmap_mode \"%(mmap_mode)s\" flag passed'\n % locals(), Warning, stacklevel=2)\n unpickler = ZipNumpyUnpickler(filename, file_handle=file_handle)\n else:\n unpickler = NumpyUnpickler(filename, file_handle=file_handle,\n mmap_mode=mmap_mode)\n\n try:\n obj = unpickler.load()\n except UnicodeDecodeError as exc:\n # More user-friendly error message\n if PY3_OR_LATER:\n new_exc = ValueError(\n 'You may be trying to read with '\n 'python 3 a joblib pickle generated with python 2. '\n 'This feature is not supported by joblib.')\n new_exc.__cause__ = exc\n raise new_exc\n finally:\n if hasattr(unpickler, 'file_handle'):\n unpickler.file_handle.close()\n return obj"},"implementation":{"kind":"string","value":" def load_build(self):\n \"\"\" This method is called to set the state of a newly created\n object.\n\n We capture it to replace our place-holder objects,\n NDArrayWrapper, by the array we are interested in. We\n replace them directly in the stack of pickler.\n \"\"\"\n Unpickler.load_build(self)\n if isinstance(self.stack[-1], NDArrayWrapper):\n if self.np is None:\n raise ImportError('Trying to unpickle an ndarray, '\n \"but numpy didn't import correctly\")\n nd_array_wrapper = self.stack.pop()\n array = nd_array_wrapper.read(self)\n self.stack.append(array)"},"start_line":{"kind":"number","value":308,"string":"308"},"end_line":{"kind":"number","value":323,"string":"323"},"file_content":{"kind":"string","value":"\"\"\"\nUtilities for fast persistence of big data, with optional compression.\n\"\"\"\n\n# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>\n# Copyright (c) 2009 Gael Varoquaux\n# License: BSD Style, 3 clauses.\n\nimport pickle\nimport traceback\nimport os\nimport zlib\nimport warnings\nfrom io import BytesIO\n\nfrom ._compat import _basestring, PY3_OR_LATER\n\n\nif PY3_OR_LATER:\n Unpickler = pickle._Unpickler\n Pickler = pickle._Pickler\n\n def asbytes(s):\n if isinstance(s, bytes):\n return s\n return s.encode('latin1')\nelse:\n Unpickler = pickle.Unpickler\n Pickler = pickle.Pickler\n asbytes = str\n\n\ndef hex_str(an_int):\n \"\"\"Converts an int to an hexadecimal string\n \"\"\"\n return '{0:#x}'.format(an_int)\n\n\n_MEGA = 2 ** 20\n\n# Compressed pickle header format: _ZFILE_PREFIX followed by _MAX_LEN\n# bytes which contains the length of the zlib compressed data as an\n# hexadecimal string. For example: 'ZF0x139 '\n_ZFILE_PREFIX = asbytes('ZF')\n_MAX_LEN = len(hex_str(2 ** 64))\n\n\n###############################################################################\n# Compressed file with Zlib\n\ndef _read_magic(file_handle):\n \"\"\" Utility to check the magic signature of a file identifying it as a\n Zfile\n \"\"\"\n magic = file_handle.read(len(_ZFILE_PREFIX))\n # Pickling needs file-handles at the beginning of the file\n file_handle.seek(0)\n return magic\n\n\ndef read_zfile(file_handle):\n \"\"\"Read the z-file and return the content as a string\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guaranteed. Do not\n use for external purposes.\n \"\"\"\n file_handle.seek(0)\n assert _read_magic(file_handle) == _ZFILE_PREFIX, \\\n \"File does not have the right magic\"\n header_length = len(_ZFILE_PREFIX) + _MAX_LEN\n length = file_handle.read(header_length)\n length = length[len(_ZFILE_PREFIX):]\n length = int(length, 16)\n\n # With python2 and joblib version <= 0.8.4 compressed pickle header is one\n # character wider so we need to ignore an additional space if present.\n # Note: the first byte of the zlib data is guaranteed not to be a\n # space according to\n # https://tools.ietf.org/html/rfc6713#section-2.1\n next_byte = file_handle.read(1)\n if next_byte != b' ':\n # The zlib compressed data has started and we need to go back\n # one byte\n file_handle.seek(header_length)\n\n # We use the known length of the data to tell Zlib the size of the\n # buffer to allocate.\n data = zlib.decompress(file_handle.read(), 15, length)\n assert len(data) == length, (\n \"Incorrect data length while decompressing %s.\"\n \"The file could be corrupted.\" % file_handle)\n return data\n\n\ndef write_zfile(file_handle, data, compress=1):\n \"\"\"Write the data in the given file as a Z-file.\n\n Z-files are raw data compressed with zlib used internally by joblib\n for persistence. Backward compatibility is not guarantied. Do not\n use for external purposes.\n \"\"\"\n file_handle.write(_ZFILE_PREFIX)\n length = hex_str(len(data))\n # Store the length of the data\n file_handle.write(asbytes(length.ljust(_MAX_LEN)))\n file_handle.write(zlib.compress(asbytes(data), compress))\n\n\n###############################################################################\n# Utility objects for persistence.\n\nclass NDArrayWrapper(object):\n \"\"\" An object to be persisted instead of numpy arrays.\n\n The only thing this object does, is to carry the filename in which\n the array has been persisted, and the array subclass.\n \"\"\"\n def __init__(self, filename, subclass, allow_mmap=True):\n \"Store the useful information for later\"\n self.filename = filename\n self.subclass = subclass\n self.allow_mmap = allow_mmap\n\n def read(self, unpickler):\n \"Reconstruct the array\"\n filename = os.path.join(unpickler._dirname, self.filename)\n # Load the array from the disk\n np_ver = [int(x) for x in unpickler.np.__version__.split('.', 2)[:2]]\n\n # use getattr instead of self.allow_mmap to ensure backward compat\n # with NDArrayWrapper instances pickled with joblib < 0.9.0\n allow_mmap = getattr(self, 'allow_mmap', True)\n memmap_kwargs = ({} if not allow_mmap\n else {'mmap_mode': unpickler.mmap_mode})\n array = unpickler.np.load(filename, **memmap_kwargs)\n # Reconstruct subclasses. This does not work with old\n # versions of numpy\n if (hasattr(array, '__array_prepare__')\n and not self.subclass in (unpickler.np.ndarray,\n unpickler.np.memmap)):\n # We need to reconstruct another subclass\n new_array = unpickler.np.core.multiarray._reconstruct(\n self.subclass, (0,), 'b')\n new_array.__array_prepare__(array)\n array = new_array\n return array\n\n #def __reduce__(self):\n # return None\n\n\nclass ZNDArrayWrapper(NDArrayWrapper):\n \"\"\"An object to be persisted instead of numpy arrays.\n\n This object store the Zfile filename in which\n the data array has been persisted, and the meta information to\n retrieve it.\n\n The reason that we store the raw buffer data of the array and\n the meta information, rather than array representation routine\n (tostring) is that it enables us to use completely the strided\n model to avoid memory copies (a and a.T store as fast). In\n addition saving the heavy information separately can avoid\n creating large temporary buffers when unpickling data with\n large arrays.\n \"\"\"\n def __init__(self, filename, init_args, state):\n \"Store the useful information for later\"\n self.filename = filename\n self.state = state\n self.init_args = init_args\n\n def read(self, unpickler):\n \"Reconstruct the array from the meta-information and the z-file\"\n # Here we a simply reproducing the unpickling mechanism for numpy\n # arrays\n filename = os.path.join(unpickler._dirname, self.filename)\n array = unpickler.np.core.multiarray._reconstruct(*self.init_args)\n with open(filename, 'rb') as f:\n data = read_zfile(f)\n state = self.state + (data,)\n array.__setstate__(state)\n return array\n\n\n###############################################################################\n# Pickler classes\n\nclass NumpyPickler(Pickler):\n \"\"\"A pickler to persist of big data efficiently.\n\n The main features of this object are:\n\n * persistence of numpy arrays in separate .npy files, for which\n I/O is fast.\n\n * optional compression using Zlib, with a special care on avoid\n temporaries.\n \"\"\"\n dispatch = Pickler.dispatch.copy()\n\n def __init__(self, filename, compress=0, cache_size=10, protocol=None):\n self._filename = filename\n self._filenames = [filename, ]\n self.cache_size = cache_size\n self.compress = compress\n if not self.compress:\n self.file = open(filename, 'wb')\n else:\n self.file = BytesIO()\n # Count the number of npy files that we have created:\n self._npy_counter = 1\n # By default we want a pickle protocol that only changes with\n # the major python version and not the minor one\n if protocol is None:\n protocol = (pickle.DEFAULT_PROTOCOL if PY3_OR_LATER\n else pickle.HIGHEST_PROTOCOL)\n\n Pickler.__init__(self, self.file,\n protocol=protocol)\n # delayed import of numpy, to avoid tight coupling\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _write_array(self, array, filename):\n if not self.compress:\n self.np.save(filename, array)\n allow_mmap = not array.dtype.hasobject\n container = NDArrayWrapper(os.path.basename(filename),\n type(array),\n allow_mmap=allow_mmap)\n else:\n filename += '.z'\n # Efficient compressed storage:\n # The meta data is stored in the container, and the core\n # numerics in a z-file\n _, init_args, state = array.__reduce__()\n # the last entry of 'state' is the data itself\n with open(filename, 'wb') as zfile:\n write_zfile(zfile, state[-1], compress=self.compress)\n state = state[:-1]\n container = ZNDArrayWrapper(os.path.basename(filename),\n init_args, state)\n return container, filename\n\n def save(self, obj):\n \"\"\" Subclass the save method, to save ndarray subclasses in npy\n files, rather than pickling them. Of course, this is a\n total abuse of the Pickler class.\n \"\"\"\n if (self.np is not None and type(obj) in\n (self.np.ndarray, self.np.matrix, self.np.memmap)):\n size = obj.size * obj.itemsize\n if self.compress and size < self.cache_size * _MEGA:\n # When compressing, as we are not writing directly to the\n # disk, it is more efficient to use standard pickling\n if type(obj) is self.np.memmap:\n # Pickling doesn't work with memmaped arrays\n obj = self.np.asarray(obj)\n return Pickler.save(self, obj)\n\n if not obj.dtype.hasobject:\n try:\n filename = '%s_%02i.npy' % (self._filename,\n self._npy_counter)\n # This converts the array in a container\n obj, filename = self._write_array(obj, filename)\n self._filenames.append(filename)\n self._npy_counter += 1\n except Exception:\n # XXX: We should have a logging mechanism\n print('Failed to save %s to .npy file:\\n%s' % (\n type(obj),\n traceback.format_exc()))\n\n return Pickler.save(self, obj)\n\n def close(self):\n if self.compress:\n with open(self._filename, 'wb') as zfile:\n write_zfile(zfile, self.file.getvalue(), self.compress)\n\n\nclass NumpyUnpickler(Unpickler):\n \"\"\"A subclass of the Unpickler to unpickle our numpy pickles.\n \"\"\"\n dispatch = Unpickler.dispatch.copy()\n\n def __init__(self, filename, file_handle, mmap_mode=None):\n self._filename = os.path.basename(filename)\n self._dirname = os.path.dirname(filename)\n self.mmap_mode = mmap_mode\n self.file_handle = self._open_pickle(file_handle)\n Unpickler.__init__(self, self.file_handle)\n try:\n import numpy as np\n except ImportError:\n np = None\n self.np = np\n\n def _open_pickle(self, file_handle):\n return file_handle\n\n def load_build(self):\n \"\"\" This method is called to set the state of a newly created\n object.\n\n We capture it to replace our place-holder objects,\n NDArrayWrapper, by the array we are interested in. We\n replace them directly in the stack of pickler.\n \"\"\"\n Unpickler.load_build(self)\n if isinstance(self.stack[-1], NDArrayWrapper):\n if self.np is None:\n raise ImportError('Trying to unpickle an ndarray, '\n \"but numpy didn't import correctly\")\n nd_array_wrapper = self.stack.pop()\n array = nd_array_wrapper.read(self)\n self.stack.append(array)\n\n # Be careful to register our new method.\n if PY3_OR_LATER:\n dispatch[pickle.BUILD[0]] = load_build\n else:\n dispatch[pickle.BUILD] = load_build\n\n\nclass ZipNumpyUnpickler(NumpyUnpickler):\n \"\"\"A subclass of our Unpickler to unpickle on the fly from\n compressed storage.\"\"\"\n\n def __init__(self, filename, file_handle):\n NumpyUnpickler.__init__(self, filename,\n file_handle,\n mmap_mode=None)\n\n def _open_pickle(self, file_handle):\n return BytesIO(read_zfile(file_handle))\n\n\n###############################################################################\n# Utility functions\n\ndef dump(value, filename, compress=0, cache_size=100, protocol=None):\n \"\"\"Fast persistence of an arbitrary Python object into one or multiple\n files, with dedicated storage for numpy arrays.\n\n Parameters\n -----------\n value: any Python object\n The object to store to disk\n filename: string\n The name of the file in which it is to be stored\n compress: integer for 0 to 9, optional\n Optional compression level for the data. 0 is no compression.\n Higher means more compression, but also slower read and\n write times. Using a value of 3 is often a good compromise.\n See the notes for more details.\n cache_size: positive number, optional\n Fixes the order of magnitude (in megabytes) of the cache used\n for in-memory compression. Note that this is just an order of\n magnitude estimate and that for big arrays, the code will go\n over this value at dump and at load time.\n protocol: positive int\n Pickle protocol, see pickle.dump documentation for more details.\n\n Returns\n -------\n filenames: list of strings\n The list of file names in which the data is stored. If\n compress is false, each array is stored in a different file.\n\n See Also\n --------\n joblib.load : corresponding loader\n\n Notes\n -----\n Memmapping on load cannot be used for compressed files. Thus\n using compression can significantly slow down loading. In\n addition, compressed files take extra extra memory during\n dump and load.\n \"\"\"\n if compress is True:\n # By default, if compress is enabled, we want to be using 3 by\n # default\n compress = 3\n if not isinstance(filename, _basestring):\n # People keep inverting arguments, and the resulting error is\n # incomprehensible\n raise ValueError(\n 'Second argument should be a filename, %s (type %s) was given'\n % (filename, type(filename))\n )\n\n try:\n pickler = NumpyPickler(filename, compress=compress,\n cache_size=cache_size, protocol=protocol)\n pickler.dump(value)\n pickler.close()\n finally:\n if 'pickler' in locals() and hasattr(pickler, 'file'):\n pickler.file.flush()\n pickler.file.close()\n return pickler._filenames\n\n\ndef load(filename, mmap_mode=None):\n \"\"\"Reconstruct a Python object from a file persisted with joblib.dump.\n\n Parameters\n -----------\n filename: string\n The name of the file from which to load the object\n mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional\n If not None, the arrays are memory-mapped from the disk. This\n mode has no effect for compressed files. Note that in this\n case the reconstructed object might not longer match exactly\n the originally pickled object.\n\n Returns\n -------\n result: any Python object\n The object stored in the file.\n\n See Also\n --------\n joblib.dump : function to save an object\n\n Notes\n -----\n\n This function can load numpy array files saved separately during the\n dump. If the mmap_mode argument is given, it is passed to np.load and\n arrays are loaded as memmaps. As a consequence, the reconstructed\n object might not match the original pickled object. Note that if the\n file was saved with compression, the arrays cannot be memmaped.\n \"\"\"\n with open(filename, 'rb') as file_handle:\n # We are careful to open the file handle early and keep it open to\n # avoid race-conditions on renames. That said, if data are stored in\n # companion files, moving the directory will create a race when\n # joblib tries to access the companion files.\n if _read_magic(file_handle) == _ZFILE_PREFIX:\n if mmap_mode is not None:\n warnings.warn('file \"%(filename)s\" appears to be a zip, '\n 'ignoring mmap_mode \"%(mmap_mode)s\" flag passed'\n % locals(), Warning, stacklevel=2)\n unpickler = ZipNumpyUnpickler(filename, file_handle=file_handle)\n else:\n unpickler = NumpyUnpickler(filename, file_handle=file_handle,\n mmap_mode=mmap_mode)\n\n try:\n obj = unpickler.load()\n except UnicodeDecodeError as exc:\n # More user-friendly error message\n if PY3_OR_LATER:\n new_exc = ValueError(\n 'You may be trying to read with '\n 'python 3 a joblib pickle generated with python 2. '\n 'This feature is not supported by joblib.')\n new_exc.__cause__ = exc\n raise new_exc\n finally:\n if hasattr(unpickler, 'file_handle'):\n unpickler.file_handle.close()\n return obj\n"}}},{"rowIdx":2069,"cells":{"function_name":{"kind":"string","value":"filter_by_size"},"docstring":{"kind":"string","value":"[deprecated] Filter indices based on their size.\nUse `FairseqDataset::filter_indices_by_size` instead.\n\nArgs:\n indices (List[int]): ordered list of dataset indices\n dataset (FairseqDataset): fairseq dataset instance\n max_positions (tuple): filter elements larger than this size.\n Comparisons are done component-wise.\n raise_exception (bool, optional): if ``True``, raise an exception if\n any elements are filtered (default: False)."},"masked_code":{"kind":"string","value":"# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\ntry:\n from collections.abc import Iterable\nexcept ImportError:\n from collections import Iterable\nimport contextlib\nimport itertools\nimport logging\nimport re\nimport warnings\nfrom typing import Optional, Tuple\n\nimport numpy as np\nimport torch\n\nfrom fairseq.file_io import PathManager\nfrom fairseq import utils\nimport os\n\nlogger = logging.getLogger(__name__)\n\n\ndef infer_language_pair(path):\n \"\"\"Infer language pair from filename: <split>.<lang1>-<lang2>.(...).idx\"\"\"\n src, dst = None, None\n for filename in PathManager.ls(path):\n parts = filename.split(\".\")\n if len(parts) >= 3 and len(parts[1].split(\"-\")) == 2:\n return parts[1].split(\"-\")\n return src, dst\n\n\ndef collate_tokens(\n values,\n pad_idx,\n eos_idx=None,\n left_pad=False,\n move_eos_to_beginning=False,\n pad_to_length=None,\n pad_to_multiple=1,\n pad_to_bsz=None,\n):\n \"\"\"Convert a list of 1d tensors into a padded 2d tensor.\"\"\"\n size = max(v.size(0) for v in values)\n size = size if pad_to_length is None else max(size, pad_to_length)\n if pad_to_multiple != 1 and size % pad_to_multiple != 0:\n size = int(((size - 0.1) // pad_to_multiple + 1) * pad_to_multiple)\n\n batch_size = len(values) if pad_to_bsz is None else max(len(values), pad_to_bsz)\n res = values[0].new(batch_size, size).fill_(pad_idx)\n\n def copy_tensor(src, dst):\n assert dst.numel() == src.numel()\n if move_eos_to_beginning:\n if eos_idx is None:\n # if no eos_idx is specified, then use the last token in src\n dst[0] = src[-1]\n else:\n dst[0] = eos_idx\n dst[1:] = src[:-1]\n else:\n dst.copy_(src)\n\n for i, v in enumerate(values):\n copy_tensor(v, res[i][size - len(v) :] if left_pad else res[i][: len(v)])\n return res\n\n\ndef load_indexed_dataset(\n path, dictionary=None, dataset_impl=None, combine=False, default=\"cached\"\n):\n \"\"\"A helper function for loading indexed datasets.\n\n Args:\n path (str): path to indexed dataset (e.g., 'data-bin/train')\n dictionary (~fairseq.data.Dictionary): data dictionary\n dataset_impl (str, optional): which dataset implementation to use. If\n not provided, it will be inferred automatically. For legacy indexed\n data we use the 'cached' implementation by default.\n combine (bool, optional): automatically load and combine multiple\n datasets. For example, if *path* is 'data-bin/train', then we will\n combine 'data-bin/train', 'data-bin/train1', ... and return a\n single ConcatDataset instance.\n \"\"\"\n import fairseq.data.indexed_dataset as indexed_dataset\n from fairseq.data.concat_dataset import ConcatDataset\n\n datasets = []\n for k in itertools.count():\n path_k = path + (str(k) if k > 0 else \"\")\n try:\n path_k = indexed_dataset.get_indexed_dataset_to_local(path_k)\n except Exception as e:\n if \"StorageException: [404] Path not found\" in str(e):\n logger.warning(f\"path_k: {e} not found\")\n else:\n raise e\n\n dataset_impl_k = dataset_impl\n if dataset_impl_k is None:\n dataset_impl_k = indexed_dataset.infer_dataset_impl(path_k)\n dataset = indexed_dataset.make_dataset(\n path_k,\n impl=dataset_impl_k or default,\n fix_lua_indexing=True,\n dictionary=dictionary,\n )\n if dataset is None:\n break\n logger.info(\"loaded {:,} examples from: {}\".format(len(dataset), path_k))\n datasets.append(dataset)\n if not combine:\n break\n if len(datasets) == 0:\n return None\n elif len(datasets) == 1:\n return datasets[0]\n else:\n return ConcatDataset(datasets)\n\n\n@contextlib.contextmanager\ndef numpy_seed(seed, *addl_seeds):\n \"\"\"Context manager which seeds the NumPy PRNG with the specified seed and\n restores the state afterward\"\"\"\n if seed is None:\n yield\n return\n if len(addl_seeds) > 0:\n seed = int(hash((seed, *addl_seeds)) % 1e6)\n state = np.random.get_state()\n np.random.seed(seed)\n try:\n yield\n finally:\n np.random.set_state(state)\n\n\ndef collect_filtered(function, iterable, filtered):\n \"\"\"\n Similar to :func:`filter` but collects filtered elements in ``filtered``.\n\n Args:\n function (callable): function that returns ``False`` for elements that\n should be filtered\n iterable (iterable): iterable to filter\n filtered (list): list to store filtered elements\n \"\"\"\n for el in iterable:\n if function(el):\n yield el\n else:\n filtered.append(el)\n\n\ndef _filter_by_size_dynamic(indices, size_fn, max_positions, raise_exception=False):\n def compare_leq(a, b):\n return a <= b if not isinstance(a, tuple) else max(a) <= b\n\n def check_size(idx):\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n return size_fn(idx) <= max_positions\n elif isinstance(max_positions, dict):\n idx_size = size_fn(idx)\n assert isinstance(idx_size, dict)\n intersect_keys = set(max_positions.keys()) & set(idx_size.keys())\n return all(\n all(\n a is None or b is None or a <= b\n for a, b in zip(idx_size[key], max_positions[key])\n )\n for key in intersect_keys\n )\n else:\n # For MultiCorpusSampledDataset, will generalize it later\n if not isinstance(size_fn(idx), Iterable):\n return all(size_fn(idx) <= b for b in max_positions)\n return all(\n a is None or b is None or a <= b\n for a, b in zip(size_fn(idx), max_positions)\n )\n\n ignored = []\n itr = collect_filtered(check_size, indices, ignored)\n indices = np.fromiter(itr, dtype=np.int64, count=-1)\n return indices, ignored\n\n\n# MASKED: filter_by_size function (lines 193-243)\n\n\ndef filter_paired_dataset_indices_by_size(src_sizes, tgt_sizes, indices, max_sizes):\n \"\"\"Filter a list of sample indices. Remove those that are longer\n than specified in max_sizes.\n\n Args:\n indices (np.array): original array of sample indices\n max_sizes (int or list[int] or tuple[int]): max sample size,\n can be defined separately for src and tgt (then list or tuple)\n\n Returns:\n np.array: filtered sample array\n list: list of removed indices\n \"\"\"\n if max_sizes is None:\n return indices, []\n if type(max_sizes) in (int, float):\n max_src_size, max_tgt_size = max_sizes, max_sizes\n else:\n max_src_size, max_tgt_size = max_sizes\n if tgt_sizes is None:\n ignored = indices[src_sizes[indices] > max_src_size]\n else:\n ignored = indices[\n (src_sizes[indices] > max_src_size) | (tgt_sizes[indices] > max_tgt_size)\n ]\n if len(ignored) > 0:\n if tgt_sizes is None:\n indices = indices[src_sizes[indices] <= max_src_size]\n else:\n indices = indices[\n (src_sizes[indices] <= max_src_size)\n & (tgt_sizes[indices] <= max_tgt_size)\n ]\n return indices, ignored.tolist()\n\n\ndef batch_by_size(\n indices,\n num_tokens_fn,\n num_tokens_vec=None,\n max_tokens=None,\n max_sentences=None,\n required_batch_size_multiple=1,\n fixed_shapes=None,\n):\n \"\"\"\n Yield mini-batches of indices bucketed by size. Batches may contain\n sequences of different lengths.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n num_tokens_fn (callable): function that returns the number of tokens at\n a given index\n num_tokens_vec (List[int], optional): precomputed vector of the number\n of tokens for each index in indices (to enable faster batch generation)\n max_tokens (int, optional): max number of tokens in each batch\n (default: None).\n max_sentences (int, optional): max number of sentences in each\n batch (default: None).\n required_batch_size_multiple (int, optional): require batch size to\n be less than N or a multiple of N (default: 1).\n fixed_shapes (List[Tuple[int, int]], optional): if given, batches will\n only be created with the given shapes. *max_sentences* and\n *required_batch_size_multiple* will be ignored (default: None).\n \"\"\"\n try:\n from fairseq.data.data_utils_fast import (\n batch_by_size_fn,\n batch_by_size_vec,\n batch_fixed_shapes_fast,\n )\n except ImportError:\n raise ImportError(\n \"Please build Cython components with: \"\n \"`python setup.py build_ext --inplace`\"\n )\n except ValueError:\n raise ValueError(\n \"Please build (or rebuild) Cython components with `python setup.py build_ext --inplace`.\"\n )\n\n # added int() to avoid TypeError: an integer is required\n max_tokens = int(max_tokens) if max_tokens is not None else -1\n max_sentences = max_sentences if max_sentences is not None else -1\n bsz_mult = required_batch_size_multiple\n\n if not isinstance(indices, np.ndarray):\n indices = np.fromiter(indices, dtype=np.int64, count=-1)\n\n if num_tokens_vec is not None and not isinstance(num_tokens_vec, np.ndarray):\n num_tokens_vec = np.fromiter(num_tokens_vec, dtype=np.int64, count=-1)\n\n if fixed_shapes is None:\n if num_tokens_vec is None:\n return batch_by_size_fn(\n indices,\n num_tokens_fn,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n else:\n return batch_by_size_vec(\n indices,\n num_tokens_vec,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n\n else:\n fixed_shapes = np.array(fixed_shapes, dtype=np.int64)\n sort_order = np.lexsort(\n [\n fixed_shapes[:, 1].argsort(), # length\n fixed_shapes[:, 0].argsort(), # bsz\n ]\n )\n fixed_shapes_sorted = fixed_shapes[sort_order]\n return batch_fixed_shapes_fast(indices, num_tokens_fn, fixed_shapes_sorted)\n\n\ndef post_process(sentence: str, symbol: str):\n if symbol == \"sentencepiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"\\u2581\", \" \").strip()\n elif symbol == \"wordpiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"_\", \" \").strip()\n elif symbol == \"letter\":\n sentence = sentence.replace(\" \", \"\").replace(\"|\", \" \").strip()\n elif symbol == \"silence\":\n import re\n\n sentence = sentence.replace(\"<SIL>\", \"\")\n sentence = re.sub(\" +\", \" \", sentence).strip()\n elif symbol == \"_EOW\":\n sentence = sentence.replace(\" \", \"\").replace(\"_EOW\", \" \").strip()\n elif symbol in {\"subword_nmt\", \"@@ \", \"@@\"}:\n if symbol == \"subword_nmt\":\n symbol = \"@@ \"\n sentence = (sentence + \" \").replace(symbol, \"\").rstrip()\n elif symbol == \"none\":\n pass\n elif symbol is not None:\n raise NotImplementedError(f\"Unknown post_process option: {symbol}\")\n return sentence\n\n\ndef compute_mask_indices(\n shape: Tuple[int, int],\n padding_mask: Optional[torch.Tensor],\n mask_prob: float,\n mask_length: int,\n mask_type: str = \"static\",\n mask_other: float = 0.0,\n min_masks: int = 0,\n no_overlap: bool = False,\n min_space: int = 0,\n) -> np.ndarray:\n \"\"\"\n Computes random mask spans for a given shape\n\n Args:\n shape: the the shape for which to compute masks.\n should be of size 2 where first element is batch size and 2nd is timesteps\n padding_mask: optional padding mask of the same size as shape, which will prevent masking padded elements\n mask_prob: probability for each token to be chosen as start of the span to be masked. this will be multiplied by\n number of timesteps divided by length of mask span to mask approximately this percentage of all elements.\n however due to overlaps, the actual number will be smaller (unless no_overlap is True)\n mask_type: how to compute mask lengths\n static = fixed size\n uniform = sample from uniform distribution [mask_other, mask_length*2]\n normal = sample from normal distribution with mean mask_length and stdev mask_other. mask is min 1 element\n poisson = sample from possion distribution with lambda = mask length\n min_masks: minimum number of masked spans\n no_overlap: if false, will switch to an alternative recursive algorithm that prevents spans from overlapping\n min_space: only used if no_overlap is True, this is how many elements to keep unmasked between spans\n \"\"\"\n\n bsz, all_sz = shape\n mask = np.full((bsz, all_sz), False)\n\n all_num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * all_sz / float(mask_length)\n + np.random.rand()\n )\n\n all_num_mask = max(min_masks, all_num_mask)\n\n mask_idcs = []\n for i in range(bsz):\n if padding_mask is not None:\n sz = all_sz - padding_mask[i].long().sum().item()\n num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * sz / float(mask_length)\n + np.random.rand()\n )\n num_mask = max(min_masks, num_mask)\n else:\n sz = all_sz\n num_mask = all_num_mask\n\n if mask_type == \"static\":\n lengths = np.full(num_mask, mask_length)\n elif mask_type == \"uniform\":\n lengths = np.random.randint(mask_other, mask_length * 2 + 1, size=num_mask)\n elif mask_type == \"normal\":\n lengths = np.random.normal(mask_length, mask_other, size=num_mask)\n lengths = [max(1, int(round(x))) for x in lengths]\n elif mask_type == \"poisson\":\n lengths = np.random.poisson(mask_length, size=num_mask)\n lengths = [int(round(x)) for x in lengths]\n else:\n raise Exception(\"unknown mask selection \" + mask_type)\n\n if sum(lengths) == 0:\n lengths[0] = min(mask_length, sz - 1)\n\n if no_overlap:\n mask_idc = []\n\n def arrange(s, e, length, keep_length):\n span_start = np.random.randint(s, e - length)\n mask_idc.extend(span_start + i for i in range(length))\n\n new_parts = []\n if span_start - s - min_space >= keep_length:\n new_parts.append((s, span_start - min_space + 1))\n if e - span_start - keep_length - min_space > keep_length:\n new_parts.append((span_start + length + min_space, e))\n return new_parts\n\n parts = [(0, sz)]\n min_length = min(lengths)\n for length in sorted(lengths, reverse=True):\n lens = np.fromiter(\n (e - s if e - s >= length + min_space else 0 for s, e in parts),\n np.int,\n )\n l_sum = np.sum(lens)\n if l_sum == 0:\n break\n probs = lens / np.sum(lens)\n c = np.random.choice(len(parts), p=probs)\n s, e = parts.pop(c)\n parts.extend(arrange(s, e, length, min_length))\n mask_idc = np.asarray(mask_idc)\n else:\n min_len = min(lengths)\n if sz - min_len <= num_mask:\n min_len = sz - num_mask - 1\n\n mask_idc = np.random.choice(sz - min_len, num_mask, replace=False)\n\n mask_idc = np.asarray(\n [\n mask_idc[j] + offset\n for j in range(len(mask_idc))\n for offset in range(lengths[j])\n ]\n )\n\n mask_idcs.append(np.unique(mask_idc[mask_idc < sz]))\n\n min_len = min([len(m) for m in mask_idcs])\n for i, mask_idc in enumerate(mask_idcs):\n if len(mask_idc) > min_len:\n mask_idc = np.random.choice(mask_idc, min_len, replace=False)\n mask[i, mask_idc] = True\n\n return mask\n\n\ndef get_mem_usage():\n try:\n import psutil\n\n mb = 1024 * 1024\n return f\"used={psutil.virtual_memory().used / mb}Mb; avail={psutil.virtual_memory().available / mb}Mb\"\n except ImportError:\n return \"N/A\"\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_padding_mask(lens):\n bsz, max_lens = lens.size(0), torch.max(lens).item()\n mask = torch.arange(max_lens).to(lens.device).view(1, max_lens)\n mask = mask.expand(bsz, -1) >= lens.view(bsz, 1).expand(-1, max_lens)\n return mask\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_mask(lens):\n return ~lengths_to_padding_mask(lens)\n\n\ndef get_buckets(sizes, num_buckets):\n buckets = np.unique(\n np.percentile(\n sizes,\n np.linspace(0, 100, num_buckets + 1),\n interpolation=\"lower\",\n )[1:]\n )\n return buckets\n\n\ndef get_bucketed_sizes(orig_sizes, buckets):\n sizes = np.copy(orig_sizes)\n assert np.min(sizes) >= 0\n start_val = -1\n for end_val in buckets:\n mask = (sizes > start_val) & (sizes <= end_val)\n sizes[mask] = end_val\n start_val = end_val\n return sizes\n\n\ndef _find_extra_valid_paths(dataset_path: str) -> set:\n paths = utils.split_paths(dataset_path)\n all_valid_paths = set()\n for sub_dir in paths:\n contents = PathManager.ls(sub_dir)\n valid_paths = [c for c in contents if re.match(\"valid*[0-9].*\", c) is not None]\n all_valid_paths |= {os.path.basename(p) for p in valid_paths}\n # Remove .bin, .idx etc\n roots = {os.path.splitext(p)[0] for p in all_valid_paths}\n return roots\n\n\ndef raise_if_valid_subsets_unintentionally_ignored(train_cfg) -> None:\n \"\"\"Raises if there are paths matching 'valid*[0-9].*' which are not combined or ignored.\"\"\"\n if (\n train_cfg.dataset.ignore_unused_valid_subsets\n or train_cfg.dataset.combine_valid_subsets\n or train_cfg.dataset.disable_validation\n or not hasattr(train_cfg.task, \"data\")\n ):\n return\n other_paths = _find_extra_valid_paths(train_cfg.task.data)\n specified_subsets = train_cfg.dataset.valid_subset.split(\",\")\n ignored_paths = [p for p in other_paths if p not in specified_subsets]\n if ignored_paths:\n advice = \"Set --combine-val to combine them or --ignore-unused-valid-subsets to ignore them.\"\n msg = f\"Valid paths {ignored_paths} will be ignored. {advice}\"\n raise ValueError(msg)"},"implementation":{"kind":"string","value":"def filter_by_size(indices, dataset, max_positions, raise_exception=False):\n \"\"\"\n [deprecated] Filter indices based on their size.\n Use `FairseqDataset::filter_indices_by_size` instead.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n dataset (FairseqDataset): fairseq dataset instance\n max_positions (tuple): filter elements larger than this size.\n Comparisons are done component-wise.\n raise_exception (bool, optional): if ``True``, raise an exception if\n any elements are filtered (default: False).\n \"\"\"\n warnings.warn(\n \"data_utils.filter_by_size is deprecated. \"\n \"Use `FairseqDataset::filter_indices_by_size` instead.\",\n stacklevel=2,\n )\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n if hasattr(dataset, \"sizes\") and isinstance(dataset.sizes, np.ndarray):\n ignored = indices[dataset.sizes[indices] > max_positions].tolist()\n indices = indices[dataset.sizes[indices] <= max_positions]\n elif (\n hasattr(dataset, \"sizes\")\n and isinstance(dataset.sizes, list)\n and len(dataset.sizes) == 1\n ):\n ignored = indices[dataset.sizes[0][indices] > max_positions].tolist()\n indices = indices[dataset.sizes[0][indices] <= max_positions]\n else:\n indices, ignored = _filter_by_size_dynamic(\n indices, dataset.size, max_positions\n )\n else:\n indices, ignored = _filter_by_size_dynamic(indices, dataset.size, max_positions)\n\n if len(ignored) > 0 and raise_exception:\n raise Exception(\n (\n \"Size of sample #{} is invalid (={}) since max_positions={}, \"\n \"skip this example with --skip-invalid-size-inputs-valid-test\"\n ).format(ignored[0], dataset.size(ignored[0]), max_positions)\n )\n if len(ignored) > 0:\n logger.warning(\n (\n \"{} samples have invalid sizes and will be skipped, \"\n \"max_positions={}, first few sample ids={}\"\n ).format(len(ignored), max_positions, ignored[:10])\n )\n return indices"},"start_line":{"kind":"number","value":193,"string":"193"},"end_line":{"kind":"number","value":243,"string":"243"},"file_content":{"kind":"string","value":"# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\ntry:\n from collections.abc import Iterable\nexcept ImportError:\n from collections import Iterable\nimport contextlib\nimport itertools\nimport logging\nimport re\nimport warnings\nfrom typing import Optional, Tuple\n\nimport numpy as np\nimport torch\n\nfrom fairseq.file_io import PathManager\nfrom fairseq import utils\nimport os\n\nlogger = logging.getLogger(__name__)\n\n\ndef infer_language_pair(path):\n \"\"\"Infer language pair from filename: <split>.<lang1>-<lang2>.(...).idx\"\"\"\n src, dst = None, None\n for filename in PathManager.ls(path):\n parts = filename.split(\".\")\n if len(parts) >= 3 and len(parts[1].split(\"-\")) == 2:\n return parts[1].split(\"-\")\n return src, dst\n\n\ndef collate_tokens(\n values,\n pad_idx,\n eos_idx=None,\n left_pad=False,\n move_eos_to_beginning=False,\n pad_to_length=None,\n pad_to_multiple=1,\n pad_to_bsz=None,\n):\n \"\"\"Convert a list of 1d tensors into a padded 2d tensor.\"\"\"\n size = max(v.size(0) for v in values)\n size = size if pad_to_length is None else max(size, pad_to_length)\n if pad_to_multiple != 1 and size % pad_to_multiple != 0:\n size = int(((size - 0.1) // pad_to_multiple + 1) * pad_to_multiple)\n\n batch_size = len(values) if pad_to_bsz is None else max(len(values), pad_to_bsz)\n res = values[0].new(batch_size, size).fill_(pad_idx)\n\n def copy_tensor(src, dst):\n assert dst.numel() == src.numel()\n if move_eos_to_beginning:\n if eos_idx is None:\n # if no eos_idx is specified, then use the last token in src\n dst[0] = src[-1]\n else:\n dst[0] = eos_idx\n dst[1:] = src[:-1]\n else:\n dst.copy_(src)\n\n for i, v in enumerate(values):\n copy_tensor(v, res[i][size - len(v) :] if left_pad else res[i][: len(v)])\n return res\n\n\ndef load_indexed_dataset(\n path, dictionary=None, dataset_impl=None, combine=False, default=\"cached\"\n):\n \"\"\"A helper function for loading indexed datasets.\n\n Args:\n path (str): path to indexed dataset (e.g., 'data-bin/train')\n dictionary (~fairseq.data.Dictionary): data dictionary\n dataset_impl (str, optional): which dataset implementation to use. If\n not provided, it will be inferred automatically. For legacy indexed\n data we use the 'cached' implementation by default.\n combine (bool, optional): automatically load and combine multiple\n datasets. For example, if *path* is 'data-bin/train', then we will\n combine 'data-bin/train', 'data-bin/train1', ... and return a\n single ConcatDataset instance.\n \"\"\"\n import fairseq.data.indexed_dataset as indexed_dataset\n from fairseq.data.concat_dataset import ConcatDataset\n\n datasets = []\n for k in itertools.count():\n path_k = path + (str(k) if k > 0 else \"\")\n try:\n path_k = indexed_dataset.get_indexed_dataset_to_local(path_k)\n except Exception as e:\n if \"StorageException: [404] Path not found\" in str(e):\n logger.warning(f\"path_k: {e} not found\")\n else:\n raise e\n\n dataset_impl_k = dataset_impl\n if dataset_impl_k is None:\n dataset_impl_k = indexed_dataset.infer_dataset_impl(path_k)\n dataset = indexed_dataset.make_dataset(\n path_k,\n impl=dataset_impl_k or default,\n fix_lua_indexing=True,\n dictionary=dictionary,\n )\n if dataset is None:\n break\n logger.info(\"loaded {:,} examples from: {}\".format(len(dataset), path_k))\n datasets.append(dataset)\n if not combine:\n break\n if len(datasets) == 0:\n return None\n elif len(datasets) == 1:\n return datasets[0]\n else:\n return ConcatDataset(datasets)\n\n\n@contextlib.contextmanager\ndef numpy_seed(seed, *addl_seeds):\n \"\"\"Context manager which seeds the NumPy PRNG with the specified seed and\n restores the state afterward\"\"\"\n if seed is None:\n yield\n return\n if len(addl_seeds) > 0:\n seed = int(hash((seed, *addl_seeds)) % 1e6)\n state = np.random.get_state()\n np.random.seed(seed)\n try:\n yield\n finally:\n np.random.set_state(state)\n\n\ndef collect_filtered(function, iterable, filtered):\n \"\"\"\n Similar to :func:`filter` but collects filtered elements in ``filtered``.\n\n Args:\n function (callable): function that returns ``False`` for elements that\n should be filtered\n iterable (iterable): iterable to filter\n filtered (list): list to store filtered elements\n \"\"\"\n for el in iterable:\n if function(el):\n yield el\n else:\n filtered.append(el)\n\n\ndef _filter_by_size_dynamic(indices, size_fn, max_positions, raise_exception=False):\n def compare_leq(a, b):\n return a <= b if not isinstance(a, tuple) else max(a) <= b\n\n def check_size(idx):\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n return size_fn(idx) <= max_positions\n elif isinstance(max_positions, dict):\n idx_size = size_fn(idx)\n assert isinstance(idx_size, dict)\n intersect_keys = set(max_positions.keys()) & set(idx_size.keys())\n return all(\n all(\n a is None or b is None or a <= b\n for a, b in zip(idx_size[key], max_positions[key])\n )\n for key in intersect_keys\n )\n else:\n # For MultiCorpusSampledDataset, will generalize it later\n if not isinstance(size_fn(idx), Iterable):\n return all(size_fn(idx) <= b for b in max_positions)\n return all(\n a is None or b is None or a <= b\n for a, b in zip(size_fn(idx), max_positions)\n )\n\n ignored = []\n itr = collect_filtered(check_size, indices, ignored)\n indices = np.fromiter(itr, dtype=np.int64, count=-1)\n return indices, ignored\n\n\ndef filter_by_size(indices, dataset, max_positions, raise_exception=False):\n \"\"\"\n [deprecated] Filter indices based on their size.\n Use `FairseqDataset::filter_indices_by_size` instead.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n dataset (FairseqDataset): fairseq dataset instance\n max_positions (tuple): filter elements larger than this size.\n Comparisons are done component-wise.\n raise_exception (bool, optional): if ``True``, raise an exception if\n any elements are filtered (default: False).\n \"\"\"\n warnings.warn(\n \"data_utils.filter_by_size is deprecated. \"\n \"Use `FairseqDataset::filter_indices_by_size` instead.\",\n stacklevel=2,\n )\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n if hasattr(dataset, \"sizes\") and isinstance(dataset.sizes, np.ndarray):\n ignored = indices[dataset.sizes[indices] > max_positions].tolist()\n indices = indices[dataset.sizes[indices] <= max_positions]\n elif (\n hasattr(dataset, \"sizes\")\n and isinstance(dataset.sizes, list)\n and len(dataset.sizes) == 1\n ):\n ignored = indices[dataset.sizes[0][indices] > max_positions].tolist()\n indices = indices[dataset.sizes[0][indices] <= max_positions]\n else:\n indices, ignored = _filter_by_size_dynamic(\n indices, dataset.size, max_positions\n )\n else:\n indices, ignored = _filter_by_size_dynamic(indices, dataset.size, max_positions)\n\n if len(ignored) > 0 and raise_exception:\n raise Exception(\n (\n \"Size of sample #{} is invalid (={}) since max_positions={}, \"\n \"skip this example with --skip-invalid-size-inputs-valid-test\"\n ).format(ignored[0], dataset.size(ignored[0]), max_positions)\n )\n if len(ignored) > 0:\n logger.warning(\n (\n \"{} samples have invalid sizes and will be skipped, \"\n \"max_positions={}, first few sample ids={}\"\n ).format(len(ignored), max_positions, ignored[:10])\n )\n return indices\n\n\ndef filter_paired_dataset_indices_by_size(src_sizes, tgt_sizes, indices, max_sizes):\n \"\"\"Filter a list of sample indices. Remove those that are longer\n than specified in max_sizes.\n\n Args:\n indices (np.array): original array of sample indices\n max_sizes (int or list[int] or tuple[int]): max sample size,\n can be defined separately for src and tgt (then list or tuple)\n\n Returns:\n np.array: filtered sample array\n list: list of removed indices\n \"\"\"\n if max_sizes is None:\n return indices, []\n if type(max_sizes) in (int, float):\n max_src_size, max_tgt_size = max_sizes, max_sizes\n else:\n max_src_size, max_tgt_size = max_sizes\n if tgt_sizes is None:\n ignored = indices[src_sizes[indices] > max_src_size]\n else:\n ignored = indices[\n (src_sizes[indices] > max_src_size) | (tgt_sizes[indices] > max_tgt_size)\n ]\n if len(ignored) > 0:\n if tgt_sizes is None:\n indices = indices[src_sizes[indices] <= max_src_size]\n else:\n indices = indices[\n (src_sizes[indices] <= max_src_size)\n & (tgt_sizes[indices] <= max_tgt_size)\n ]\n return indices, ignored.tolist()\n\n\ndef batch_by_size(\n indices,\n num_tokens_fn,\n num_tokens_vec=None,\n max_tokens=None,\n max_sentences=None,\n required_batch_size_multiple=1,\n fixed_shapes=None,\n):\n \"\"\"\n Yield mini-batches of indices bucketed by size. Batches may contain\n sequences of different lengths.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n num_tokens_fn (callable): function that returns the number of tokens at\n a given index\n num_tokens_vec (List[int], optional): precomputed vector of the number\n of tokens for each index in indices (to enable faster batch generation)\n max_tokens (int, optional): max number of tokens in each batch\n (default: None).\n max_sentences (int, optional): max number of sentences in each\n batch (default: None).\n required_batch_size_multiple (int, optional): require batch size to\n be less than N or a multiple of N (default: 1).\n fixed_shapes (List[Tuple[int, int]], optional): if given, batches will\n only be created with the given shapes. *max_sentences* and\n *required_batch_size_multiple* will be ignored (default: None).\n \"\"\"\n try:\n from fairseq.data.data_utils_fast import (\n batch_by_size_fn,\n batch_by_size_vec,\n batch_fixed_shapes_fast,\n )\n except ImportError:\n raise ImportError(\n \"Please build Cython components with: \"\n \"`python setup.py build_ext --inplace`\"\n )\n except ValueError:\n raise ValueError(\n \"Please build (or rebuild) Cython components with `python setup.py build_ext --inplace`.\"\n )\n\n # added int() to avoid TypeError: an integer is required\n max_tokens = int(max_tokens) if max_tokens is not None else -1\n max_sentences = max_sentences if max_sentences is not None else -1\n bsz_mult = required_batch_size_multiple\n\n if not isinstance(indices, np.ndarray):\n indices = np.fromiter(indices, dtype=np.int64, count=-1)\n\n if num_tokens_vec is not None and not isinstance(num_tokens_vec, np.ndarray):\n num_tokens_vec = np.fromiter(num_tokens_vec, dtype=np.int64, count=-1)\n\n if fixed_shapes is None:\n if num_tokens_vec is None:\n return batch_by_size_fn(\n indices,\n num_tokens_fn,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n else:\n return batch_by_size_vec(\n indices,\n num_tokens_vec,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n\n else:\n fixed_shapes = np.array(fixed_shapes, dtype=np.int64)\n sort_order = np.lexsort(\n [\n fixed_shapes[:, 1].argsort(), # length\n fixed_shapes[:, 0].argsort(), # bsz\n ]\n )\n fixed_shapes_sorted = fixed_shapes[sort_order]\n return batch_fixed_shapes_fast(indices, num_tokens_fn, fixed_shapes_sorted)\n\n\ndef post_process(sentence: str, symbol: str):\n if symbol == \"sentencepiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"\\u2581\", \" \").strip()\n elif symbol == \"wordpiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"_\", \" \").strip()\n elif symbol == \"letter\":\n sentence = sentence.replace(\" \", \"\").replace(\"|\", \" \").strip()\n elif symbol == \"silence\":\n import re\n\n sentence = sentence.replace(\"<SIL>\", \"\")\n sentence = re.sub(\" +\", \" \", sentence).strip()\n elif symbol == \"_EOW\":\n sentence = sentence.replace(\" \", \"\").replace(\"_EOW\", \" \").strip()\n elif symbol in {\"subword_nmt\", \"@@ \", \"@@\"}:\n if symbol == \"subword_nmt\":\n symbol = \"@@ \"\n sentence = (sentence + \" \").replace(symbol, \"\").rstrip()\n elif symbol == \"none\":\n pass\n elif symbol is not None:\n raise NotImplementedError(f\"Unknown post_process option: {symbol}\")\n return sentence\n\n\ndef compute_mask_indices(\n shape: Tuple[int, int],\n padding_mask: Optional[torch.Tensor],\n mask_prob: float,\n mask_length: int,\n mask_type: str = \"static\",\n mask_other: float = 0.0,\n min_masks: int = 0,\n no_overlap: bool = False,\n min_space: int = 0,\n) -> np.ndarray:\n \"\"\"\n Computes random mask spans for a given shape\n\n Args:\n shape: the the shape for which to compute masks.\n should be of size 2 where first element is batch size and 2nd is timesteps\n padding_mask: optional padding mask of the same size as shape, which will prevent masking padded elements\n mask_prob: probability for each token to be chosen as start of the span to be masked. this will be multiplied by\n number of timesteps divided by length of mask span to mask approximately this percentage of all elements.\n however due to overlaps, the actual number will be smaller (unless no_overlap is True)\n mask_type: how to compute mask lengths\n static = fixed size\n uniform = sample from uniform distribution [mask_other, mask_length*2]\n normal = sample from normal distribution with mean mask_length and stdev mask_other. mask is min 1 element\n poisson = sample from possion distribution with lambda = mask length\n min_masks: minimum number of masked spans\n no_overlap: if false, will switch to an alternative recursive algorithm that prevents spans from overlapping\n min_space: only used if no_overlap is True, this is how many elements to keep unmasked between spans\n \"\"\"\n\n bsz, all_sz = shape\n mask = np.full((bsz, all_sz), False)\n\n all_num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * all_sz / float(mask_length)\n + np.random.rand()\n )\n\n all_num_mask = max(min_masks, all_num_mask)\n\n mask_idcs = []\n for i in range(bsz):\n if padding_mask is not None:\n sz = all_sz - padding_mask[i].long().sum().item()\n num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * sz / float(mask_length)\n + np.random.rand()\n )\n num_mask = max(min_masks, num_mask)\n else:\n sz = all_sz\n num_mask = all_num_mask\n\n if mask_type == \"static\":\n lengths = np.full(num_mask, mask_length)\n elif mask_type == \"uniform\":\n lengths = np.random.randint(mask_other, mask_length * 2 + 1, size=num_mask)\n elif mask_type == \"normal\":\n lengths = np.random.normal(mask_length, mask_other, size=num_mask)\n lengths = [max(1, int(round(x))) for x in lengths]\n elif mask_type == \"poisson\":\n lengths = np.random.poisson(mask_length, size=num_mask)\n lengths = [int(round(x)) for x in lengths]\n else:\n raise Exception(\"unknown mask selection \" + mask_type)\n\n if sum(lengths) == 0:\n lengths[0] = min(mask_length, sz - 1)\n\n if no_overlap:\n mask_idc = []\n\n def arrange(s, e, length, keep_length):\n span_start = np.random.randint(s, e - length)\n mask_idc.extend(span_start + i for i in range(length))\n\n new_parts = []\n if span_start - s - min_space >= keep_length:\n new_parts.append((s, span_start - min_space + 1))\n if e - span_start - keep_length - min_space > keep_length:\n new_parts.append((span_start + length + min_space, e))\n return new_parts\n\n parts = [(0, sz)]\n min_length = min(lengths)\n for length in sorted(lengths, reverse=True):\n lens = np.fromiter(\n (e - s if e - s >= length + min_space else 0 for s, e in parts),\n np.int,\n )\n l_sum = np.sum(lens)\n if l_sum == 0:\n break\n probs = lens / np.sum(lens)\n c = np.random.choice(len(parts), p=probs)\n s, e = parts.pop(c)\n parts.extend(arrange(s, e, length, min_length))\n mask_idc = np.asarray(mask_idc)\n else:\n min_len = min(lengths)\n if sz - min_len <= num_mask:\n min_len = sz - num_mask - 1\n\n mask_idc = np.random.choice(sz - min_len, num_mask, replace=False)\n\n mask_idc = np.asarray(\n [\n mask_idc[j] + offset\n for j in range(len(mask_idc))\n for offset in range(lengths[j])\n ]\n )\n\n mask_idcs.append(np.unique(mask_idc[mask_idc < sz]))\n\n min_len = min([len(m) for m in mask_idcs])\n for i, mask_idc in enumerate(mask_idcs):\n if len(mask_idc) > min_len:\n mask_idc = np.random.choice(mask_idc, min_len, replace=False)\n mask[i, mask_idc] = True\n\n return mask\n\n\ndef get_mem_usage():\n try:\n import psutil\n\n mb = 1024 * 1024\n return f\"used={psutil.virtual_memory().used / mb}Mb; avail={psutil.virtual_memory().available / mb}Mb\"\n except ImportError:\n return \"N/A\"\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_padding_mask(lens):\n bsz, max_lens = lens.size(0), torch.max(lens).item()\n mask = torch.arange(max_lens).to(lens.device).view(1, max_lens)\n mask = mask.expand(bsz, -1) >= lens.view(bsz, 1).expand(-1, max_lens)\n return mask\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_mask(lens):\n return ~lengths_to_padding_mask(lens)\n\n\ndef get_buckets(sizes, num_buckets):\n buckets = np.unique(\n np.percentile(\n sizes,\n np.linspace(0, 100, num_buckets + 1),\n interpolation=\"lower\",\n )[1:]\n )\n return buckets\n\n\ndef get_bucketed_sizes(orig_sizes, buckets):\n sizes = np.copy(orig_sizes)\n assert np.min(sizes) >= 0\n start_val = -1\n for end_val in buckets:\n mask = (sizes > start_val) & (sizes <= end_val)\n sizes[mask] = end_val\n start_val = end_val\n return sizes\n\n\ndef _find_extra_valid_paths(dataset_path: str) -> set:\n paths = utils.split_paths(dataset_path)\n all_valid_paths = set()\n for sub_dir in paths:\n contents = PathManager.ls(sub_dir)\n valid_paths = [c for c in contents if re.match(\"valid*[0-9].*\", c) is not None]\n all_valid_paths |= {os.path.basename(p) for p in valid_paths}\n # Remove .bin, .idx etc\n roots = {os.path.splitext(p)[0] for p in all_valid_paths}\n return roots\n\n\ndef raise_if_valid_subsets_unintentionally_ignored(train_cfg) -> None:\n \"\"\"Raises if there are paths matching 'valid*[0-9].*' which are not combined or ignored.\"\"\"\n if (\n train_cfg.dataset.ignore_unused_valid_subsets\n or train_cfg.dataset.combine_valid_subsets\n or train_cfg.dataset.disable_validation\n or not hasattr(train_cfg.task, \"data\")\n ):\n return\n other_paths = _find_extra_valid_paths(train_cfg.task.data)\n specified_subsets = train_cfg.dataset.valid_subset.split(\",\")\n ignored_paths = [p for p in other_paths if p not in specified_subsets]\n if ignored_paths:\n advice = \"Set --combine-val to combine them or --ignore-unused-valid-subsets to ignore them.\"\n msg = f\"Valid paths {ignored_paths} will be ignored. {advice}\"\n raise ValueError(msg)\n"}}},{"rowIdx":2070,"cells":{"function_name":{"kind":"string","value":"filter_paired_dataset_indices_by_size"},"docstring":{"kind":"string","value":"Filter a list of sample indices. Remove those that are longer\n than specified in max_sizes.\n\nArgs:\n indices (np.array): original array of sample indices\n max_sizes (int or list[int] or tuple[int]): max sample size,\n can be defined separately for src and tgt (then list or tuple)\n\nReturns:\n np.array: filtered sample array\n list: list of removed indices"},"masked_code":{"kind":"string","value":"# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\ntry:\n from collections.abc import Iterable\nexcept ImportError:\n from collections import Iterable\nimport contextlib\nimport itertools\nimport logging\nimport re\nimport warnings\nfrom typing import Optional, Tuple\n\nimport numpy as np\nimport torch\n\nfrom fairseq.file_io import PathManager\nfrom fairseq import utils\nimport os\n\nlogger = logging.getLogger(__name__)\n\n\ndef infer_language_pair(path):\n \"\"\"Infer language pair from filename: <split>.<lang1>-<lang2>.(...).idx\"\"\"\n src, dst = None, None\n for filename in PathManager.ls(path):\n parts = filename.split(\".\")\n if len(parts) >= 3 and len(parts[1].split(\"-\")) == 2:\n return parts[1].split(\"-\")\n return src, dst\n\n\ndef collate_tokens(\n values,\n pad_idx,\n eos_idx=None,\n left_pad=False,\n move_eos_to_beginning=False,\n pad_to_length=None,\n pad_to_multiple=1,\n pad_to_bsz=None,\n):\n \"\"\"Convert a list of 1d tensors into a padded 2d tensor.\"\"\"\n size = max(v.size(0) for v in values)\n size = size if pad_to_length is None else max(size, pad_to_length)\n if pad_to_multiple != 1 and size % pad_to_multiple != 0:\n size = int(((size - 0.1) // pad_to_multiple + 1) * pad_to_multiple)\n\n batch_size = len(values) if pad_to_bsz is None else max(len(values), pad_to_bsz)\n res = values[0].new(batch_size, size).fill_(pad_idx)\n\n def copy_tensor(src, dst):\n assert dst.numel() == src.numel()\n if move_eos_to_beginning:\n if eos_idx is None:\n # if no eos_idx is specified, then use the last token in src\n dst[0] = src[-1]\n else:\n dst[0] = eos_idx\n dst[1:] = src[:-1]\n else:\n dst.copy_(src)\n\n for i, v in enumerate(values):\n copy_tensor(v, res[i][size - len(v) :] if left_pad else res[i][: len(v)])\n return res\n\n\ndef load_indexed_dataset(\n path, dictionary=None, dataset_impl=None, combine=False, default=\"cached\"\n):\n \"\"\"A helper function for loading indexed datasets.\n\n Args:\n path (str): path to indexed dataset (e.g., 'data-bin/train')\n dictionary (~fairseq.data.Dictionary): data dictionary\n dataset_impl (str, optional): which dataset implementation to use. If\n not provided, it will be inferred automatically. For legacy indexed\n data we use the 'cached' implementation by default.\n combine (bool, optional): automatically load and combine multiple\n datasets. For example, if *path* is 'data-bin/train', then we will\n combine 'data-bin/train', 'data-bin/train1', ... and return a\n single ConcatDataset instance.\n \"\"\"\n import fairseq.data.indexed_dataset as indexed_dataset\n from fairseq.data.concat_dataset import ConcatDataset\n\n datasets = []\n for k in itertools.count():\n path_k = path + (str(k) if k > 0 else \"\")\n try:\n path_k = indexed_dataset.get_indexed_dataset_to_local(path_k)\n except Exception as e:\n if \"StorageException: [404] Path not found\" in str(e):\n logger.warning(f\"path_k: {e} not found\")\n else:\n raise e\n\n dataset_impl_k = dataset_impl\n if dataset_impl_k is None:\n dataset_impl_k = indexed_dataset.infer_dataset_impl(path_k)\n dataset = indexed_dataset.make_dataset(\n path_k,\n impl=dataset_impl_k or default,\n fix_lua_indexing=True,\n dictionary=dictionary,\n )\n if dataset is None:\n break\n logger.info(\"loaded {:,} examples from: {}\".format(len(dataset), path_k))\n datasets.append(dataset)\n if not combine:\n break\n if len(datasets) == 0:\n return None\n elif len(datasets) == 1:\n return datasets[0]\n else:\n return ConcatDataset(datasets)\n\n\n@contextlib.contextmanager\ndef numpy_seed(seed, *addl_seeds):\n \"\"\"Context manager which seeds the NumPy PRNG with the specified seed and\n restores the state afterward\"\"\"\n if seed is None:\n yield\n return\n if len(addl_seeds) > 0:\n seed = int(hash((seed, *addl_seeds)) % 1e6)\n state = np.random.get_state()\n np.random.seed(seed)\n try:\n yield\n finally:\n np.random.set_state(state)\n\n\ndef collect_filtered(function, iterable, filtered):\n \"\"\"\n Similar to :func:`filter` but collects filtered elements in ``filtered``.\n\n Args:\n function (callable): function that returns ``False`` for elements that\n should be filtered\n iterable (iterable): iterable to filter\n filtered (list): list to store filtered elements\n \"\"\"\n for el in iterable:\n if function(el):\n yield el\n else:\n filtered.append(el)\n\n\ndef _filter_by_size_dynamic(indices, size_fn, max_positions, raise_exception=False):\n def compare_leq(a, b):\n return a <= b if not isinstance(a, tuple) else max(a) <= b\n\n def check_size(idx):\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n return size_fn(idx) <= max_positions\n elif isinstance(max_positions, dict):\n idx_size = size_fn(idx)\n assert isinstance(idx_size, dict)\n intersect_keys = set(max_positions.keys()) & set(idx_size.keys())\n return all(\n all(\n a is None or b is None or a <= b\n for a, b in zip(idx_size[key], max_positions[key])\n )\n for key in intersect_keys\n )\n else:\n # For MultiCorpusSampledDataset, will generalize it later\n if not isinstance(size_fn(idx), Iterable):\n return all(size_fn(idx) <= b for b in max_positions)\n return all(\n a is None or b is None or a <= b\n for a, b in zip(size_fn(idx), max_positions)\n )\n\n ignored = []\n itr = collect_filtered(check_size, indices, ignored)\n indices = np.fromiter(itr, dtype=np.int64, count=-1)\n return indices, ignored\n\n\ndef filter_by_size(indices, dataset, max_positions, raise_exception=False):\n \"\"\"\n [deprecated] Filter indices based on their size.\n Use `FairseqDataset::filter_indices_by_size` instead.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n dataset (FairseqDataset): fairseq dataset instance\n max_positions (tuple): filter elements larger than this size.\n Comparisons are done component-wise.\n raise_exception (bool, optional): if ``True``, raise an exception if\n any elements are filtered (default: False).\n \"\"\"\n warnings.warn(\n \"data_utils.filter_by_size is deprecated. \"\n \"Use `FairseqDataset::filter_indices_by_size` instead.\",\n stacklevel=2,\n )\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n if hasattr(dataset, \"sizes\") and isinstance(dataset.sizes, np.ndarray):\n ignored = indices[dataset.sizes[indices] > max_positions].tolist()\n indices = indices[dataset.sizes[indices] <= max_positions]\n elif (\n hasattr(dataset, \"sizes\")\n and isinstance(dataset.sizes, list)\n and len(dataset.sizes) == 1\n ):\n ignored = indices[dataset.sizes[0][indices] > max_positions].tolist()\n indices = indices[dataset.sizes[0][indices] <= max_positions]\n else:\n indices, ignored = _filter_by_size_dynamic(\n indices, dataset.size, max_positions\n )\n else:\n indices, ignored = _filter_by_size_dynamic(indices, dataset.size, max_positions)\n\n if len(ignored) > 0 and raise_exception:\n raise Exception(\n (\n \"Size of sample #{} is invalid (={}) since max_positions={}, \"\n \"skip this example with --skip-invalid-size-inputs-valid-test\"\n ).format(ignored[0], dataset.size(ignored[0]), max_positions)\n )\n if len(ignored) > 0:\n logger.warning(\n (\n \"{} samples have invalid sizes and will be skipped, \"\n \"max_positions={}, first few sample ids={}\"\n ).format(len(ignored), max_positions, ignored[:10])\n )\n return indices\n\n\n# MASKED: filter_paired_dataset_indices_by_size function (lines 246-279)\n\n\ndef batch_by_size(\n indices,\n num_tokens_fn,\n num_tokens_vec=None,\n max_tokens=None,\n max_sentences=None,\n required_batch_size_multiple=1,\n fixed_shapes=None,\n):\n \"\"\"\n Yield mini-batches of indices bucketed by size. Batches may contain\n sequences of different lengths.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n num_tokens_fn (callable): function that returns the number of tokens at\n a given index\n num_tokens_vec (List[int], optional): precomputed vector of the number\n of tokens for each index in indices (to enable faster batch generation)\n max_tokens (int, optional): max number of tokens in each batch\n (default: None).\n max_sentences (int, optional): max number of sentences in each\n batch (default: None).\n required_batch_size_multiple (int, optional): require batch size to\n be less than N or a multiple of N (default: 1).\n fixed_shapes (List[Tuple[int, int]], optional): if given, batches will\n only be created with the given shapes. *max_sentences* and\n *required_batch_size_multiple* will be ignored (default: None).\n \"\"\"\n try:\n from fairseq.data.data_utils_fast import (\n batch_by_size_fn,\n batch_by_size_vec,\n batch_fixed_shapes_fast,\n )\n except ImportError:\n raise ImportError(\n \"Please build Cython components with: \"\n \"`python setup.py build_ext --inplace`\"\n )\n except ValueError:\n raise ValueError(\n \"Please build (or rebuild) Cython components with `python setup.py build_ext --inplace`.\"\n )\n\n # added int() to avoid TypeError: an integer is required\n max_tokens = int(max_tokens) if max_tokens is not None else -1\n max_sentences = max_sentences if max_sentences is not None else -1\n bsz_mult = required_batch_size_multiple\n\n if not isinstance(indices, np.ndarray):\n indices = np.fromiter(indices, dtype=np.int64, count=-1)\n\n if num_tokens_vec is not None and not isinstance(num_tokens_vec, np.ndarray):\n num_tokens_vec = np.fromiter(num_tokens_vec, dtype=np.int64, count=-1)\n\n if fixed_shapes is None:\n if num_tokens_vec is None:\n return batch_by_size_fn(\n indices,\n num_tokens_fn,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n else:\n return batch_by_size_vec(\n indices,\n num_tokens_vec,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n\n else:\n fixed_shapes = np.array(fixed_shapes, dtype=np.int64)\n sort_order = np.lexsort(\n [\n fixed_shapes[:, 1].argsort(), # length\n fixed_shapes[:, 0].argsort(), # bsz\n ]\n )\n fixed_shapes_sorted = fixed_shapes[sort_order]\n return batch_fixed_shapes_fast(indices, num_tokens_fn, fixed_shapes_sorted)\n\n\ndef post_process(sentence: str, symbol: str):\n if symbol == \"sentencepiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"\\u2581\", \" \").strip()\n elif symbol == \"wordpiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"_\", \" \").strip()\n elif symbol == \"letter\":\n sentence = sentence.replace(\" \", \"\").replace(\"|\", \" \").strip()\n elif symbol == \"silence\":\n import re\n\n sentence = sentence.replace(\"<SIL>\", \"\")\n sentence = re.sub(\" +\", \" \", sentence).strip()\n elif symbol == \"_EOW\":\n sentence = sentence.replace(\" \", \"\").replace(\"_EOW\", \" \").strip()\n elif symbol in {\"subword_nmt\", \"@@ \", \"@@\"}:\n if symbol == \"subword_nmt\":\n symbol = \"@@ \"\n sentence = (sentence + \" \").replace(symbol, \"\").rstrip()\n elif symbol == \"none\":\n pass\n elif symbol is not None:\n raise NotImplementedError(f\"Unknown post_process option: {symbol}\")\n return sentence\n\n\ndef compute_mask_indices(\n shape: Tuple[int, int],\n padding_mask: Optional[torch.Tensor],\n mask_prob: float,\n mask_length: int,\n mask_type: str = \"static\",\n mask_other: float = 0.0,\n min_masks: int = 0,\n no_overlap: bool = False,\n min_space: int = 0,\n) -> np.ndarray:\n \"\"\"\n Computes random mask spans for a given shape\n\n Args:\n shape: the the shape for which to compute masks.\n should be of size 2 where first element is batch size and 2nd is timesteps\n padding_mask: optional padding mask of the same size as shape, which will prevent masking padded elements\n mask_prob: probability for each token to be chosen as start of the span to be masked. this will be multiplied by\n number of timesteps divided by length of mask span to mask approximately this percentage of all elements.\n however due to overlaps, the actual number will be smaller (unless no_overlap is True)\n mask_type: how to compute mask lengths\n static = fixed size\n uniform = sample from uniform distribution [mask_other, mask_length*2]\n normal = sample from normal distribution with mean mask_length and stdev mask_other. mask is min 1 element\n poisson = sample from possion distribution with lambda = mask length\n min_masks: minimum number of masked spans\n no_overlap: if false, will switch to an alternative recursive algorithm that prevents spans from overlapping\n min_space: only used if no_overlap is True, this is how many elements to keep unmasked between spans\n \"\"\"\n\n bsz, all_sz = shape\n mask = np.full((bsz, all_sz), False)\n\n all_num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * all_sz / float(mask_length)\n + np.random.rand()\n )\n\n all_num_mask = max(min_masks, all_num_mask)\n\n mask_idcs = []\n for i in range(bsz):\n if padding_mask is not None:\n sz = all_sz - padding_mask[i].long().sum().item()\n num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * sz / float(mask_length)\n + np.random.rand()\n )\n num_mask = max(min_masks, num_mask)\n else:\n sz = all_sz\n num_mask = all_num_mask\n\n if mask_type == \"static\":\n lengths = np.full(num_mask, mask_length)\n elif mask_type == \"uniform\":\n lengths = np.random.randint(mask_other, mask_length * 2 + 1, size=num_mask)\n elif mask_type == \"normal\":\n lengths = np.random.normal(mask_length, mask_other, size=num_mask)\n lengths = [max(1, int(round(x))) for x in lengths]\n elif mask_type == \"poisson\":\n lengths = np.random.poisson(mask_length, size=num_mask)\n lengths = [int(round(x)) for x in lengths]\n else:\n raise Exception(\"unknown mask selection \" + mask_type)\n\n if sum(lengths) == 0:\n lengths[0] = min(mask_length, sz - 1)\n\n if no_overlap:\n mask_idc = []\n\n def arrange(s, e, length, keep_length):\n span_start = np.random.randint(s, e - length)\n mask_idc.extend(span_start + i for i in range(length))\n\n new_parts = []\n if span_start - s - min_space >= keep_length:\n new_parts.append((s, span_start - min_space + 1))\n if e - span_start - keep_length - min_space > keep_length:\n new_parts.append((span_start + length + min_space, e))\n return new_parts\n\n parts = [(0, sz)]\n min_length = min(lengths)\n for length in sorted(lengths, reverse=True):\n lens = np.fromiter(\n (e - s if e - s >= length + min_space else 0 for s, e in parts),\n np.int,\n )\n l_sum = np.sum(lens)\n if l_sum == 0:\n break\n probs = lens / np.sum(lens)\n c = np.random.choice(len(parts), p=probs)\n s, e = parts.pop(c)\n parts.extend(arrange(s, e, length, min_length))\n mask_idc = np.asarray(mask_idc)\n else:\n min_len = min(lengths)\n if sz - min_len <= num_mask:\n min_len = sz - num_mask - 1\n\n mask_idc = np.random.choice(sz - min_len, num_mask, replace=False)\n\n mask_idc = np.asarray(\n [\n mask_idc[j] + offset\n for j in range(len(mask_idc))\n for offset in range(lengths[j])\n ]\n )\n\n mask_idcs.append(np.unique(mask_idc[mask_idc < sz]))\n\n min_len = min([len(m) for m in mask_idcs])\n for i, mask_idc in enumerate(mask_idcs):\n if len(mask_idc) > min_len:\n mask_idc = np.random.choice(mask_idc, min_len, replace=False)\n mask[i, mask_idc] = True\n\n return mask\n\n\ndef get_mem_usage():\n try:\n import psutil\n\n mb = 1024 * 1024\n return f\"used={psutil.virtual_memory().used / mb}Mb; avail={psutil.virtual_memory().available / mb}Mb\"\n except ImportError:\n return \"N/A\"\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_padding_mask(lens):\n bsz, max_lens = lens.size(0), torch.max(lens).item()\n mask = torch.arange(max_lens).to(lens.device).view(1, max_lens)\n mask = mask.expand(bsz, -1) >= lens.view(bsz, 1).expand(-1, max_lens)\n return mask\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_mask(lens):\n return ~lengths_to_padding_mask(lens)\n\n\ndef get_buckets(sizes, num_buckets):\n buckets = np.unique(\n np.percentile(\n sizes,\n np.linspace(0, 100, num_buckets + 1),\n interpolation=\"lower\",\n )[1:]\n )\n return buckets\n\n\ndef get_bucketed_sizes(orig_sizes, buckets):\n sizes = np.copy(orig_sizes)\n assert np.min(sizes) >= 0\n start_val = -1\n for end_val in buckets:\n mask = (sizes > start_val) & (sizes <= end_val)\n sizes[mask] = end_val\n start_val = end_val\n return sizes\n\n\ndef _find_extra_valid_paths(dataset_path: str) -> set:\n paths = utils.split_paths(dataset_path)\n all_valid_paths = set()\n for sub_dir in paths:\n contents = PathManager.ls(sub_dir)\n valid_paths = [c for c in contents if re.match(\"valid*[0-9].*\", c) is not None]\n all_valid_paths |= {os.path.basename(p) for p in valid_paths}\n # Remove .bin, .idx etc\n roots = {os.path.splitext(p)[0] for p in all_valid_paths}\n return roots\n\n\ndef raise_if_valid_subsets_unintentionally_ignored(train_cfg) -> None:\n \"\"\"Raises if there are paths matching 'valid*[0-9].*' which are not combined or ignored.\"\"\"\n if (\n train_cfg.dataset.ignore_unused_valid_subsets\n or train_cfg.dataset.combine_valid_subsets\n or train_cfg.dataset.disable_validation\n or not hasattr(train_cfg.task, \"data\")\n ):\n return\n other_paths = _find_extra_valid_paths(train_cfg.task.data)\n specified_subsets = train_cfg.dataset.valid_subset.split(\",\")\n ignored_paths = [p for p in other_paths if p not in specified_subsets]\n if ignored_paths:\n advice = \"Set --combine-val to combine them or --ignore-unused-valid-subsets to ignore them.\"\n msg = f\"Valid paths {ignored_paths} will be ignored. {advice}\"\n raise ValueError(msg)"},"implementation":{"kind":"string","value":"def filter_paired_dataset_indices_by_size(src_sizes, tgt_sizes, indices, max_sizes):\n \"\"\"Filter a list of sample indices. Remove those that are longer\n than specified in max_sizes.\n\n Args:\n indices (np.array): original array of sample indices\n max_sizes (int or list[int] or tuple[int]): max sample size,\n can be defined separately for src and tgt (then list or tuple)\n\n Returns:\n np.array: filtered sample array\n list: list of removed indices\n \"\"\"\n if max_sizes is None:\n return indices, []\n if type(max_sizes) in (int, float):\n max_src_size, max_tgt_size = max_sizes, max_sizes\n else:\n max_src_size, max_tgt_size = max_sizes\n if tgt_sizes is None:\n ignored = indices[src_sizes[indices] > max_src_size]\n else:\n ignored = indices[\n (src_sizes[indices] > max_src_size) | (tgt_sizes[indices] > max_tgt_size)\n ]\n if len(ignored) > 0:\n if tgt_sizes is None:\n indices = indices[src_sizes[indices] <= max_src_size]\n else:\n indices = indices[\n (src_sizes[indices] <= max_src_size)\n & (tgt_sizes[indices] <= max_tgt_size)\n ]\n return indices, ignored.tolist()"},"start_line":{"kind":"number","value":246,"string":"246"},"end_line":{"kind":"number","value":279,"string":"279"},"file_content":{"kind":"string","value":"# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\ntry:\n from collections.abc import Iterable\nexcept ImportError:\n from collections import Iterable\nimport contextlib\nimport itertools\nimport logging\nimport re\nimport warnings\nfrom typing import Optional, Tuple\n\nimport numpy as np\nimport torch\n\nfrom fairseq.file_io import PathManager\nfrom fairseq import utils\nimport os\n\nlogger = logging.getLogger(__name__)\n\n\ndef infer_language_pair(path):\n \"\"\"Infer language pair from filename: <split>.<lang1>-<lang2>.(...).idx\"\"\"\n src, dst = None, None\n for filename in PathManager.ls(path):\n parts = filename.split(\".\")\n if len(parts) >= 3 and len(parts[1].split(\"-\")) == 2:\n return parts[1].split(\"-\")\n return src, dst\n\n\ndef collate_tokens(\n values,\n pad_idx,\n eos_idx=None,\n left_pad=False,\n move_eos_to_beginning=False,\n pad_to_length=None,\n pad_to_multiple=1,\n pad_to_bsz=None,\n):\n \"\"\"Convert a list of 1d tensors into a padded 2d tensor.\"\"\"\n size = max(v.size(0) for v in values)\n size = size if pad_to_length is None else max(size, pad_to_length)\n if pad_to_multiple != 1 and size % pad_to_multiple != 0:\n size = int(((size - 0.1) // pad_to_multiple + 1) * pad_to_multiple)\n\n batch_size = len(values) if pad_to_bsz is None else max(len(values), pad_to_bsz)\n res = values[0].new(batch_size, size).fill_(pad_idx)\n\n def copy_tensor(src, dst):\n assert dst.numel() == src.numel()\n if move_eos_to_beginning:\n if eos_idx is None:\n # if no eos_idx is specified, then use the last token in src\n dst[0] = src[-1]\n else:\n dst[0] = eos_idx\n dst[1:] = src[:-1]\n else:\n dst.copy_(src)\n\n for i, v in enumerate(values):\n copy_tensor(v, res[i][size - len(v) :] if left_pad else res[i][: len(v)])\n return res\n\n\ndef load_indexed_dataset(\n path, dictionary=None, dataset_impl=None, combine=False, default=\"cached\"\n):\n \"\"\"A helper function for loading indexed datasets.\n\n Args:\n path (str): path to indexed dataset (e.g., 'data-bin/train')\n dictionary (~fairseq.data.Dictionary): data dictionary\n dataset_impl (str, optional): which dataset implementation to use. If\n not provided, it will be inferred automatically. For legacy indexed\n data we use the 'cached' implementation by default.\n combine (bool, optional): automatically load and combine multiple\n datasets. For example, if *path* is 'data-bin/train', then we will\n combine 'data-bin/train', 'data-bin/train1', ... and return a\n single ConcatDataset instance.\n \"\"\"\n import fairseq.data.indexed_dataset as indexed_dataset\n from fairseq.data.concat_dataset import ConcatDataset\n\n datasets = []\n for k in itertools.count():\n path_k = path + (str(k) if k > 0 else \"\")\n try:\n path_k = indexed_dataset.get_indexed_dataset_to_local(path_k)\n except Exception as e:\n if \"StorageException: [404] Path not found\" in str(e):\n logger.warning(f\"path_k: {e} not found\")\n else:\n raise e\n\n dataset_impl_k = dataset_impl\n if dataset_impl_k is None:\n dataset_impl_k = indexed_dataset.infer_dataset_impl(path_k)\n dataset = indexed_dataset.make_dataset(\n path_k,\n impl=dataset_impl_k or default,\n fix_lua_indexing=True,\n dictionary=dictionary,\n )\n if dataset is None:\n break\n logger.info(\"loaded {:,} examples from: {}\".format(len(dataset), path_k))\n datasets.append(dataset)\n if not combine:\n break\n if len(datasets) == 0:\n return None\n elif len(datasets) == 1:\n return datasets[0]\n else:\n return ConcatDataset(datasets)\n\n\n@contextlib.contextmanager\ndef numpy_seed(seed, *addl_seeds):\n \"\"\"Context manager which seeds the NumPy PRNG with the specified seed and\n restores the state afterward\"\"\"\n if seed is None:\n yield\n return\n if len(addl_seeds) > 0:\n seed = int(hash((seed, *addl_seeds)) % 1e6)\n state = np.random.get_state()\n np.random.seed(seed)\n try:\n yield\n finally:\n np.random.set_state(state)\n\n\ndef collect_filtered(function, iterable, filtered):\n \"\"\"\n Similar to :func:`filter` but collects filtered elements in ``filtered``.\n\n Args:\n function (callable): function that returns ``False`` for elements that\n should be filtered\n iterable (iterable): iterable to filter\n filtered (list): list to store filtered elements\n \"\"\"\n for el in iterable:\n if function(el):\n yield el\n else:\n filtered.append(el)\n\n\ndef _filter_by_size_dynamic(indices, size_fn, max_positions, raise_exception=False):\n def compare_leq(a, b):\n return a <= b if not isinstance(a, tuple) else max(a) <= b\n\n def check_size(idx):\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n return size_fn(idx) <= max_positions\n elif isinstance(max_positions, dict):\n idx_size = size_fn(idx)\n assert isinstance(idx_size, dict)\n intersect_keys = set(max_positions.keys()) & set(idx_size.keys())\n return all(\n all(\n a is None or b is None or a <= b\n for a, b in zip(idx_size[key], max_positions[key])\n )\n for key in intersect_keys\n )\n else:\n # For MultiCorpusSampledDataset, will generalize it later\n if not isinstance(size_fn(idx), Iterable):\n return all(size_fn(idx) <= b for b in max_positions)\n return all(\n a is None or b is None or a <= b\n for a, b in zip(size_fn(idx), max_positions)\n )\n\n ignored = []\n itr = collect_filtered(check_size, indices, ignored)\n indices = np.fromiter(itr, dtype=np.int64, count=-1)\n return indices, ignored\n\n\ndef filter_by_size(indices, dataset, max_positions, raise_exception=False):\n \"\"\"\n [deprecated] Filter indices based on their size.\n Use `FairseqDataset::filter_indices_by_size` instead.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n dataset (FairseqDataset): fairseq dataset instance\n max_positions (tuple): filter elements larger than this size.\n Comparisons are done component-wise.\n raise_exception (bool, optional): if ``True``, raise an exception if\n any elements are filtered (default: False).\n \"\"\"\n warnings.warn(\n \"data_utils.filter_by_size is deprecated. \"\n \"Use `FairseqDataset::filter_indices_by_size` instead.\",\n stacklevel=2,\n )\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n if hasattr(dataset, \"sizes\") and isinstance(dataset.sizes, np.ndarray):\n ignored = indices[dataset.sizes[indices] > max_positions].tolist()\n indices = indices[dataset.sizes[indices] <= max_positions]\n elif (\n hasattr(dataset, \"sizes\")\n and isinstance(dataset.sizes, list)\n and len(dataset.sizes) == 1\n ):\n ignored = indices[dataset.sizes[0][indices] > max_positions].tolist()\n indices = indices[dataset.sizes[0][indices] <= max_positions]\n else:\n indices, ignored = _filter_by_size_dynamic(\n indices, dataset.size, max_positions\n )\n else:\n indices, ignored = _filter_by_size_dynamic(indices, dataset.size, max_positions)\n\n if len(ignored) > 0 and raise_exception:\n raise Exception(\n (\n \"Size of sample #{} is invalid (={}) since max_positions={}, \"\n \"skip this example with --skip-invalid-size-inputs-valid-test\"\n ).format(ignored[0], dataset.size(ignored[0]), max_positions)\n )\n if len(ignored) > 0:\n logger.warning(\n (\n \"{} samples have invalid sizes and will be skipped, \"\n \"max_positions={}, first few sample ids={}\"\n ).format(len(ignored), max_positions, ignored[:10])\n )\n return indices\n\n\ndef filter_paired_dataset_indices_by_size(src_sizes, tgt_sizes, indices, max_sizes):\n \"\"\"Filter a list of sample indices. Remove those that are longer\n than specified in max_sizes.\n\n Args:\n indices (np.array): original array of sample indices\n max_sizes (int or list[int] or tuple[int]): max sample size,\n can be defined separately for src and tgt (then list or tuple)\n\n Returns:\n np.array: filtered sample array\n list: list of removed indices\n \"\"\"\n if max_sizes is None:\n return indices, []\n if type(max_sizes) in (int, float):\n max_src_size, max_tgt_size = max_sizes, max_sizes\n else:\n max_src_size, max_tgt_size = max_sizes\n if tgt_sizes is None:\n ignored = indices[src_sizes[indices] > max_src_size]\n else:\n ignored = indices[\n (src_sizes[indices] > max_src_size) | (tgt_sizes[indices] > max_tgt_size)\n ]\n if len(ignored) > 0:\n if tgt_sizes is None:\n indices = indices[src_sizes[indices] <= max_src_size]\n else:\n indices = indices[\n (src_sizes[indices] <= max_src_size)\n & (tgt_sizes[indices] <= max_tgt_size)\n ]\n return indices, ignored.tolist()\n\n\ndef batch_by_size(\n indices,\n num_tokens_fn,\n num_tokens_vec=None,\n max_tokens=None,\n max_sentences=None,\n required_batch_size_multiple=1,\n fixed_shapes=None,\n):\n \"\"\"\n Yield mini-batches of indices bucketed by size. Batches may contain\n sequences of different lengths.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n num_tokens_fn (callable): function that returns the number of tokens at\n a given index\n num_tokens_vec (List[int], optional): precomputed vector of the number\n of tokens for each index in indices (to enable faster batch generation)\n max_tokens (int, optional): max number of tokens in each batch\n (default: None).\n max_sentences (int, optional): max number of sentences in each\n batch (default: None).\n required_batch_size_multiple (int, optional): require batch size to\n be less than N or a multiple of N (default: 1).\n fixed_shapes (List[Tuple[int, int]], optional): if given, batches will\n only be created with the given shapes. *max_sentences* and\n *required_batch_size_multiple* will be ignored (default: None).\n \"\"\"\n try:\n from fairseq.data.data_utils_fast import (\n batch_by_size_fn,\n batch_by_size_vec,\n batch_fixed_shapes_fast,\n )\n except ImportError:\n raise ImportError(\n \"Please build Cython components with: \"\n \"`python setup.py build_ext --inplace`\"\n )\n except ValueError:\n raise ValueError(\n \"Please build (or rebuild) Cython components with `python setup.py build_ext --inplace`.\"\n )\n\n # added int() to avoid TypeError: an integer is required\n max_tokens = int(max_tokens) if max_tokens is not None else -1\n max_sentences = max_sentences if max_sentences is not None else -1\n bsz_mult = required_batch_size_multiple\n\n if not isinstance(indices, np.ndarray):\n indices = np.fromiter(indices, dtype=np.int64, count=-1)\n\n if num_tokens_vec is not None and not isinstance(num_tokens_vec, np.ndarray):\n num_tokens_vec = np.fromiter(num_tokens_vec, dtype=np.int64, count=-1)\n\n if fixed_shapes is None:\n if num_tokens_vec is None:\n return batch_by_size_fn(\n indices,\n num_tokens_fn,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n else:\n return batch_by_size_vec(\n indices,\n num_tokens_vec,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n\n else:\n fixed_shapes = np.array(fixed_shapes, dtype=np.int64)\n sort_order = np.lexsort(\n [\n fixed_shapes[:, 1].argsort(), # length\n fixed_shapes[:, 0].argsort(), # bsz\n ]\n )\n fixed_shapes_sorted = fixed_shapes[sort_order]\n return batch_fixed_shapes_fast(indices, num_tokens_fn, fixed_shapes_sorted)\n\n\ndef post_process(sentence: str, symbol: str):\n if symbol == \"sentencepiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"\\u2581\", \" \").strip()\n elif symbol == \"wordpiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"_\", \" \").strip()\n elif symbol == \"letter\":\n sentence = sentence.replace(\" \", \"\").replace(\"|\", \" \").strip()\n elif symbol == \"silence\":\n import re\n\n sentence = sentence.replace(\"<SIL>\", \"\")\n sentence = re.sub(\" +\", \" \", sentence).strip()\n elif symbol == \"_EOW\":\n sentence = sentence.replace(\" \", \"\").replace(\"_EOW\", \" \").strip()\n elif symbol in {\"subword_nmt\", \"@@ \", \"@@\"}:\n if symbol == \"subword_nmt\":\n symbol = \"@@ \"\n sentence = (sentence + \" \").replace(symbol, \"\").rstrip()\n elif symbol == \"none\":\n pass\n elif symbol is not None:\n raise NotImplementedError(f\"Unknown post_process option: {symbol}\")\n return sentence\n\n\ndef compute_mask_indices(\n shape: Tuple[int, int],\n padding_mask: Optional[torch.Tensor],\n mask_prob: float,\n mask_length: int,\n mask_type: str = \"static\",\n mask_other: float = 0.0,\n min_masks: int = 0,\n no_overlap: bool = False,\n min_space: int = 0,\n) -> np.ndarray:\n \"\"\"\n Computes random mask spans for a given shape\n\n Args:\n shape: the the shape for which to compute masks.\n should be of size 2 where first element is batch size and 2nd is timesteps\n padding_mask: optional padding mask of the same size as shape, which will prevent masking padded elements\n mask_prob: probability for each token to be chosen as start of the span to be masked. this will be multiplied by\n number of timesteps divided by length of mask span to mask approximately this percentage of all elements.\n however due to overlaps, the actual number will be smaller (unless no_overlap is True)\n mask_type: how to compute mask lengths\n static = fixed size\n uniform = sample from uniform distribution [mask_other, mask_length*2]\n normal = sample from normal distribution with mean mask_length and stdev mask_other. mask is min 1 element\n poisson = sample from possion distribution with lambda = mask length\n min_masks: minimum number of masked spans\n no_overlap: if false, will switch to an alternative recursive algorithm that prevents spans from overlapping\n min_space: only used if no_overlap is True, this is how many elements to keep unmasked between spans\n \"\"\"\n\n bsz, all_sz = shape\n mask = np.full((bsz, all_sz), False)\n\n all_num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * all_sz / float(mask_length)\n + np.random.rand()\n )\n\n all_num_mask = max(min_masks, all_num_mask)\n\n mask_idcs = []\n for i in range(bsz):\n if padding_mask is not None:\n sz = all_sz - padding_mask[i].long().sum().item()\n num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * sz / float(mask_length)\n + np.random.rand()\n )\n num_mask = max(min_masks, num_mask)\n else:\n sz = all_sz\n num_mask = all_num_mask\n\n if mask_type == \"static\":\n lengths = np.full(num_mask, mask_length)\n elif mask_type == \"uniform\":\n lengths = np.random.randint(mask_other, mask_length * 2 + 1, size=num_mask)\n elif mask_type == \"normal\":\n lengths = np.random.normal(mask_length, mask_other, size=num_mask)\n lengths = [max(1, int(round(x))) for x in lengths]\n elif mask_type == \"poisson\":\n lengths = np.random.poisson(mask_length, size=num_mask)\n lengths = [int(round(x)) for x in lengths]\n else:\n raise Exception(\"unknown mask selection \" + mask_type)\n\n if sum(lengths) == 0:\n lengths[0] = min(mask_length, sz - 1)\n\n if no_overlap:\n mask_idc = []\n\n def arrange(s, e, length, keep_length):\n span_start = np.random.randint(s, e - length)\n mask_idc.extend(span_start + i for i in range(length))\n\n new_parts = []\n if span_start - s - min_space >= keep_length:\n new_parts.append((s, span_start - min_space + 1))\n if e - span_start - keep_length - min_space > keep_length:\n new_parts.append((span_start + length + min_space, e))\n return new_parts\n\n parts = [(0, sz)]\n min_length = min(lengths)\n for length in sorted(lengths, reverse=True):\n lens = np.fromiter(\n (e - s if e - s >= length + min_space else 0 for s, e in parts),\n np.int,\n )\n l_sum = np.sum(lens)\n if l_sum == 0:\n break\n probs = lens / np.sum(lens)\n c = np.random.choice(len(parts), p=probs)\n s, e = parts.pop(c)\n parts.extend(arrange(s, e, length, min_length))\n mask_idc = np.asarray(mask_idc)\n else:\n min_len = min(lengths)\n if sz - min_len <= num_mask:\n min_len = sz - num_mask - 1\n\n mask_idc = np.random.choice(sz - min_len, num_mask, replace=False)\n\n mask_idc = np.asarray(\n [\n mask_idc[j] + offset\n for j in range(len(mask_idc))\n for offset in range(lengths[j])\n ]\n )\n\n mask_idcs.append(np.unique(mask_idc[mask_idc < sz]))\n\n min_len = min([len(m) for m in mask_idcs])\n for i, mask_idc in enumerate(mask_idcs):\n if len(mask_idc) > min_len:\n mask_idc = np.random.choice(mask_idc, min_len, replace=False)\n mask[i, mask_idc] = True\n\n return mask\n\n\ndef get_mem_usage():\n try:\n import psutil\n\n mb = 1024 * 1024\n return f\"used={psutil.virtual_memory().used / mb}Mb; avail={psutil.virtual_memory().available / mb}Mb\"\n except ImportError:\n return \"N/A\"\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_padding_mask(lens):\n bsz, max_lens = lens.size(0), torch.max(lens).item()\n mask = torch.arange(max_lens).to(lens.device).view(1, max_lens)\n mask = mask.expand(bsz, -1) >= lens.view(bsz, 1).expand(-1, max_lens)\n return mask\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_mask(lens):\n return ~lengths_to_padding_mask(lens)\n\n\ndef get_buckets(sizes, num_buckets):\n buckets = np.unique(\n np.percentile(\n sizes,\n np.linspace(0, 100, num_buckets + 1),\n interpolation=\"lower\",\n )[1:]\n )\n return buckets\n\n\ndef get_bucketed_sizes(orig_sizes, buckets):\n sizes = np.copy(orig_sizes)\n assert np.min(sizes) >= 0\n start_val = -1\n for end_val in buckets:\n mask = (sizes > start_val) & (sizes <= end_val)\n sizes[mask] = end_val\n start_val = end_val\n return sizes\n\n\ndef _find_extra_valid_paths(dataset_path: str) -> set:\n paths = utils.split_paths(dataset_path)\n all_valid_paths = set()\n for sub_dir in paths:\n contents = PathManager.ls(sub_dir)\n valid_paths = [c for c in contents if re.match(\"valid*[0-9].*\", c) is not None]\n all_valid_paths |= {os.path.basename(p) for p in valid_paths}\n # Remove .bin, .idx etc\n roots = {os.path.splitext(p)[0] for p in all_valid_paths}\n return roots\n\n\ndef raise_if_valid_subsets_unintentionally_ignored(train_cfg) -> None:\n \"\"\"Raises if there are paths matching 'valid*[0-9].*' which are not combined or ignored.\"\"\"\n if (\n train_cfg.dataset.ignore_unused_valid_subsets\n or train_cfg.dataset.combine_valid_subsets\n or train_cfg.dataset.disable_validation\n or not hasattr(train_cfg.task, \"data\")\n ):\n return\n other_paths = _find_extra_valid_paths(train_cfg.task.data)\n specified_subsets = train_cfg.dataset.valid_subset.split(\",\")\n ignored_paths = [p for p in other_paths if p not in specified_subsets]\n if ignored_paths:\n advice = \"Set --combine-val to combine them or --ignore-unused-valid-subsets to ignore them.\"\n msg = f\"Valid paths {ignored_paths} will be ignored. {advice}\"\n raise ValueError(msg)\n"}}},{"rowIdx":2071,"cells":{"function_name":{"kind":"string","value":"batch_by_size"},"docstring":{"kind":"string","value":"Yield mini-batches of indices bucketed by size. Batches may contain\nsequences of different lengths.\n\nArgs:\n indices (List[int]): ordered list of dataset indices\n num_tokens_fn (callable): function that returns the number of tokens at\n a given index\n num_tokens_vec (List[int], optional): precomputed vector of the number\n of tokens for each index in indices (to enable faster batch generation)\n max_tokens (int, optional): max number of tokens in each batch\n (default: None).\n max_sentences (int, optional): max number of sentences in each\n batch (default: None).\n required_batch_size_multiple (int, optional): require batch size to\n be less than N or a multiple of N (default: 1).\n fixed_shapes (List[Tuple[int, int]], optional): if given, batches will\n only be created with the given shapes. *max_sentences* and\n *required_batch_size_multiple* will be ignored (default: None)."},"masked_code":{"kind":"string","value":"# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\ntry:\n from collections.abc import Iterable\nexcept ImportError:\n from collections import Iterable\nimport contextlib\nimport itertools\nimport logging\nimport re\nimport warnings\nfrom typing import Optional, Tuple\n\nimport numpy as np\nimport torch\n\nfrom fairseq.file_io import PathManager\nfrom fairseq import utils\nimport os\n\nlogger = logging.getLogger(__name__)\n\n\ndef infer_language_pair(path):\n \"\"\"Infer language pair from filename: <split>.<lang1>-<lang2>.(...).idx\"\"\"\n src, dst = None, None\n for filename in PathManager.ls(path):\n parts = filename.split(\".\")\n if len(parts) >= 3 and len(parts[1].split(\"-\")) == 2:\n return parts[1].split(\"-\")\n return src, dst\n\n\ndef collate_tokens(\n values,\n pad_idx,\n eos_idx=None,\n left_pad=False,\n move_eos_to_beginning=False,\n pad_to_length=None,\n pad_to_multiple=1,\n pad_to_bsz=None,\n):\n \"\"\"Convert a list of 1d tensors into a padded 2d tensor.\"\"\"\n size = max(v.size(0) for v in values)\n size = size if pad_to_length is None else max(size, pad_to_length)\n if pad_to_multiple != 1 and size % pad_to_multiple != 0:\n size = int(((size - 0.1) // pad_to_multiple + 1) * pad_to_multiple)\n\n batch_size = len(values) if pad_to_bsz is None else max(len(values), pad_to_bsz)\n res = values[0].new(batch_size, size).fill_(pad_idx)\n\n def copy_tensor(src, dst):\n assert dst.numel() == src.numel()\n if move_eos_to_beginning:\n if eos_idx is None:\n # if no eos_idx is specified, then use the last token in src\n dst[0] = src[-1]\n else:\n dst[0] = eos_idx\n dst[1:] = src[:-1]\n else:\n dst.copy_(src)\n\n for i, v in enumerate(values):\n copy_tensor(v, res[i][size - len(v) :] if left_pad else res[i][: len(v)])\n return res\n\n\ndef load_indexed_dataset(\n path, dictionary=None, dataset_impl=None, combine=False, default=\"cached\"\n):\n \"\"\"A helper function for loading indexed datasets.\n\n Args:\n path (str): path to indexed dataset (e.g., 'data-bin/train')\n dictionary (~fairseq.data.Dictionary): data dictionary\n dataset_impl (str, optional): which dataset implementation to use. If\n not provided, it will be inferred automatically. For legacy indexed\n data we use the 'cached' implementation by default.\n combine (bool, optional): automatically load and combine multiple\n datasets. For example, if *path* is 'data-bin/train', then we will\n combine 'data-bin/train', 'data-bin/train1', ... and return a\n single ConcatDataset instance.\n \"\"\"\n import fairseq.data.indexed_dataset as indexed_dataset\n from fairseq.data.concat_dataset import ConcatDataset\n\n datasets = []\n for k in itertools.count():\n path_k = path + (str(k) if k > 0 else \"\")\n try:\n path_k = indexed_dataset.get_indexed_dataset_to_local(path_k)\n except Exception as e:\n if \"StorageException: [404] Path not found\" in str(e):\n logger.warning(f\"path_k: {e} not found\")\n else:\n raise e\n\n dataset_impl_k = dataset_impl\n if dataset_impl_k is None:\n dataset_impl_k = indexed_dataset.infer_dataset_impl(path_k)\n dataset = indexed_dataset.make_dataset(\n path_k,\n impl=dataset_impl_k or default,\n fix_lua_indexing=True,\n dictionary=dictionary,\n )\n if dataset is None:\n break\n logger.info(\"loaded {:,} examples from: {}\".format(len(dataset), path_k))\n datasets.append(dataset)\n if not combine:\n break\n if len(datasets) == 0:\n return None\n elif len(datasets) == 1:\n return datasets[0]\n else:\n return ConcatDataset(datasets)\n\n\n@contextlib.contextmanager\ndef numpy_seed(seed, *addl_seeds):\n \"\"\"Context manager which seeds the NumPy PRNG with the specified seed and\n restores the state afterward\"\"\"\n if seed is None:\n yield\n return\n if len(addl_seeds) > 0:\n seed = int(hash((seed, *addl_seeds)) % 1e6)\n state = np.random.get_state()\n np.random.seed(seed)\n try:\n yield\n finally:\n np.random.set_state(state)\n\n\ndef collect_filtered(function, iterable, filtered):\n \"\"\"\n Similar to :func:`filter` but collects filtered elements in ``filtered``.\n\n Args:\n function (callable): function that returns ``False`` for elements that\n should be filtered\n iterable (iterable): iterable to filter\n filtered (list): list to store filtered elements\n \"\"\"\n for el in iterable:\n if function(el):\n yield el\n else:\n filtered.append(el)\n\n\ndef _filter_by_size_dynamic(indices, size_fn, max_positions, raise_exception=False):\n def compare_leq(a, b):\n return a <= b if not isinstance(a, tuple) else max(a) <= b\n\n def check_size(idx):\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n return size_fn(idx) <= max_positions\n elif isinstance(max_positions, dict):\n idx_size = size_fn(idx)\n assert isinstance(idx_size, dict)\n intersect_keys = set(max_positions.keys()) & set(idx_size.keys())\n return all(\n all(\n a is None or b is None or a <= b\n for a, b in zip(idx_size[key], max_positions[key])\n )\n for key in intersect_keys\n )\n else:\n # For MultiCorpusSampledDataset, will generalize it later\n if not isinstance(size_fn(idx), Iterable):\n return all(size_fn(idx) <= b for b in max_positions)\n return all(\n a is None or b is None or a <= b\n for a, b in zip(size_fn(idx), max_positions)\n )\n\n ignored = []\n itr = collect_filtered(check_size, indices, ignored)\n indices = np.fromiter(itr, dtype=np.int64, count=-1)\n return indices, ignored\n\n\ndef filter_by_size(indices, dataset, max_positions, raise_exception=False):\n \"\"\"\n [deprecated] Filter indices based on their size.\n Use `FairseqDataset::filter_indices_by_size` instead.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n dataset (FairseqDataset): fairseq dataset instance\n max_positions (tuple): filter elements larger than this size.\n Comparisons are done component-wise.\n raise_exception (bool, optional): if ``True``, raise an exception if\n any elements are filtered (default: False).\n \"\"\"\n warnings.warn(\n \"data_utils.filter_by_size is deprecated. \"\n \"Use `FairseqDataset::filter_indices_by_size` instead.\",\n stacklevel=2,\n )\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n if hasattr(dataset, \"sizes\") and isinstance(dataset.sizes, np.ndarray):\n ignored = indices[dataset.sizes[indices] > max_positions].tolist()\n indices = indices[dataset.sizes[indices] <= max_positions]\n elif (\n hasattr(dataset, \"sizes\")\n and isinstance(dataset.sizes, list)\n and len(dataset.sizes) == 1\n ):\n ignored = indices[dataset.sizes[0][indices] > max_positions].tolist()\n indices = indices[dataset.sizes[0][indices] <= max_positions]\n else:\n indices, ignored = _filter_by_size_dynamic(\n indices, dataset.size, max_positions\n )\n else:\n indices, ignored = _filter_by_size_dynamic(indices, dataset.size, max_positions)\n\n if len(ignored) > 0 and raise_exception:\n raise Exception(\n (\n \"Size of sample #{} is invalid (={}) since max_positions={}, \"\n \"skip this example with --skip-invalid-size-inputs-valid-test\"\n ).format(ignored[0], dataset.size(ignored[0]), max_positions)\n )\n if len(ignored) > 0:\n logger.warning(\n (\n \"{} samples have invalid sizes and will be skipped, \"\n \"max_positions={}, first few sample ids={}\"\n ).format(len(ignored), max_positions, ignored[:10])\n )\n return indices\n\n\ndef filter_paired_dataset_indices_by_size(src_sizes, tgt_sizes, indices, max_sizes):\n \"\"\"Filter a list of sample indices. Remove those that are longer\n than specified in max_sizes.\n\n Args:\n indices (np.array): original array of sample indices\n max_sizes (int or list[int] or tuple[int]): max sample size,\n can be defined separately for src and tgt (then list or tuple)\n\n Returns:\n np.array: filtered sample array\n list: list of removed indices\n \"\"\"\n if max_sizes is None:\n return indices, []\n if type(max_sizes) in (int, float):\n max_src_size, max_tgt_size = max_sizes, max_sizes\n else:\n max_src_size, max_tgt_size = max_sizes\n if tgt_sizes is None:\n ignored = indices[src_sizes[indices] > max_src_size]\n else:\n ignored = indices[\n (src_sizes[indices] > max_src_size) | (tgt_sizes[indices] > max_tgt_size)\n ]\n if len(ignored) > 0:\n if tgt_sizes is None:\n indices = indices[src_sizes[indices] <= max_src_size]\n else:\n indices = indices[\n (src_sizes[indices] <= max_src_size)\n & (tgt_sizes[indices] <= max_tgt_size)\n ]\n return indices, ignored.tolist()\n\n\n# MASKED: batch_by_size function (lines 282-365)\n\n\ndef post_process(sentence: str, symbol: str):\n if symbol == \"sentencepiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"\\u2581\", \" \").strip()\n elif symbol == \"wordpiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"_\", \" \").strip()\n elif symbol == \"letter\":\n sentence = sentence.replace(\" \", \"\").replace(\"|\", \" \").strip()\n elif symbol == \"silence\":\n import re\n\n sentence = sentence.replace(\"<SIL>\", \"\")\n sentence = re.sub(\" +\", \" \", sentence).strip()\n elif symbol == \"_EOW\":\n sentence = sentence.replace(\" \", \"\").replace(\"_EOW\", \" \").strip()\n elif symbol in {\"subword_nmt\", \"@@ \", \"@@\"}:\n if symbol == \"subword_nmt\":\n symbol = \"@@ \"\n sentence = (sentence + \" \").replace(symbol, \"\").rstrip()\n elif symbol == \"none\":\n pass\n elif symbol is not None:\n raise NotImplementedError(f\"Unknown post_process option: {symbol}\")\n return sentence\n\n\ndef compute_mask_indices(\n shape: Tuple[int, int],\n padding_mask: Optional[torch.Tensor],\n mask_prob: float,\n mask_length: int,\n mask_type: str = \"static\",\n mask_other: float = 0.0,\n min_masks: int = 0,\n no_overlap: bool = False,\n min_space: int = 0,\n) -> np.ndarray:\n \"\"\"\n Computes random mask spans for a given shape\n\n Args:\n shape: the the shape for which to compute masks.\n should be of size 2 where first element is batch size and 2nd is timesteps\n padding_mask: optional padding mask of the same size as shape, which will prevent masking padded elements\n mask_prob: probability for each token to be chosen as start of the span to be masked. this will be multiplied by\n number of timesteps divided by length of mask span to mask approximately this percentage of all elements.\n however due to overlaps, the actual number will be smaller (unless no_overlap is True)\n mask_type: how to compute mask lengths\n static = fixed size\n uniform = sample from uniform distribution [mask_other, mask_length*2]\n normal = sample from normal distribution with mean mask_length and stdev mask_other. mask is min 1 element\n poisson = sample from possion distribution with lambda = mask length\n min_masks: minimum number of masked spans\n no_overlap: if false, will switch to an alternative recursive algorithm that prevents spans from overlapping\n min_space: only used if no_overlap is True, this is how many elements to keep unmasked between spans\n \"\"\"\n\n bsz, all_sz = shape\n mask = np.full((bsz, all_sz), False)\n\n all_num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * all_sz / float(mask_length)\n + np.random.rand()\n )\n\n all_num_mask = max(min_masks, all_num_mask)\n\n mask_idcs = []\n for i in range(bsz):\n if padding_mask is not None:\n sz = all_sz - padding_mask[i].long().sum().item()\n num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * sz / float(mask_length)\n + np.random.rand()\n )\n num_mask = max(min_masks, num_mask)\n else:\n sz = all_sz\n num_mask = all_num_mask\n\n if mask_type == \"static\":\n lengths = np.full(num_mask, mask_length)\n elif mask_type == \"uniform\":\n lengths = np.random.randint(mask_other, mask_length * 2 + 1, size=num_mask)\n elif mask_type == \"normal\":\n lengths = np.random.normal(mask_length, mask_other, size=num_mask)\n lengths = [max(1, int(round(x))) for x in lengths]\n elif mask_type == \"poisson\":\n lengths = np.random.poisson(mask_length, size=num_mask)\n lengths = [int(round(x)) for x in lengths]\n else:\n raise Exception(\"unknown mask selection \" + mask_type)\n\n if sum(lengths) == 0:\n lengths[0] = min(mask_length, sz - 1)\n\n if no_overlap:\n mask_idc = []\n\n def arrange(s, e, length, keep_length):\n span_start = np.random.randint(s, e - length)\n mask_idc.extend(span_start + i for i in range(length))\n\n new_parts = []\n if span_start - s - min_space >= keep_length:\n new_parts.append((s, span_start - min_space + 1))\n if e - span_start - keep_length - min_space > keep_length:\n new_parts.append((span_start + length + min_space, e))\n return new_parts\n\n parts = [(0, sz)]\n min_length = min(lengths)\n for length in sorted(lengths, reverse=True):\n lens = np.fromiter(\n (e - s if e - s >= length + min_space else 0 for s, e in parts),\n np.int,\n )\n l_sum = np.sum(lens)\n if l_sum == 0:\n break\n probs = lens / np.sum(lens)\n c = np.random.choice(len(parts), p=probs)\n s, e = parts.pop(c)\n parts.extend(arrange(s, e, length, min_length))\n mask_idc = np.asarray(mask_idc)\n else:\n min_len = min(lengths)\n if sz - min_len <= num_mask:\n min_len = sz - num_mask - 1\n\n mask_idc = np.random.choice(sz - min_len, num_mask, replace=False)\n\n mask_idc = np.asarray(\n [\n mask_idc[j] + offset\n for j in range(len(mask_idc))\n for offset in range(lengths[j])\n ]\n )\n\n mask_idcs.append(np.unique(mask_idc[mask_idc < sz]))\n\n min_len = min([len(m) for m in mask_idcs])\n for i, mask_idc in enumerate(mask_idcs):\n if len(mask_idc) > min_len:\n mask_idc = np.random.choice(mask_idc, min_len, replace=False)\n mask[i, mask_idc] = True\n\n return mask\n\n\ndef get_mem_usage():\n try:\n import psutil\n\n mb = 1024 * 1024\n return f\"used={psutil.virtual_memory().used / mb}Mb; avail={psutil.virtual_memory().available / mb}Mb\"\n except ImportError:\n return \"N/A\"\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_padding_mask(lens):\n bsz, max_lens = lens.size(0), torch.max(lens).item()\n mask = torch.arange(max_lens).to(lens.device).view(1, max_lens)\n mask = mask.expand(bsz, -1) >= lens.view(bsz, 1).expand(-1, max_lens)\n return mask\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_mask(lens):\n return ~lengths_to_padding_mask(lens)\n\n\ndef get_buckets(sizes, num_buckets):\n buckets = np.unique(\n np.percentile(\n sizes,\n np.linspace(0, 100, num_buckets + 1),\n interpolation=\"lower\",\n )[1:]\n )\n return buckets\n\n\ndef get_bucketed_sizes(orig_sizes, buckets):\n sizes = np.copy(orig_sizes)\n assert np.min(sizes) >= 0\n start_val = -1\n for end_val in buckets:\n mask = (sizes > start_val) & (sizes <= end_val)\n sizes[mask] = end_val\n start_val = end_val\n return sizes\n\n\ndef _find_extra_valid_paths(dataset_path: str) -> set:\n paths = utils.split_paths(dataset_path)\n all_valid_paths = set()\n for sub_dir in paths:\n contents = PathManager.ls(sub_dir)\n valid_paths = [c for c in contents if re.match(\"valid*[0-9].*\", c) is not None]\n all_valid_paths |= {os.path.basename(p) for p in valid_paths}\n # Remove .bin, .idx etc\n roots = {os.path.splitext(p)[0] for p in all_valid_paths}\n return roots\n\n\ndef raise_if_valid_subsets_unintentionally_ignored(train_cfg) -> None:\n \"\"\"Raises if there are paths matching 'valid*[0-9].*' which are not combined or ignored.\"\"\"\n if (\n train_cfg.dataset.ignore_unused_valid_subsets\n or train_cfg.dataset.combine_valid_subsets\n or train_cfg.dataset.disable_validation\n or not hasattr(train_cfg.task, \"data\")\n ):\n return\n other_paths = _find_extra_valid_paths(train_cfg.task.data)\n specified_subsets = train_cfg.dataset.valid_subset.split(\",\")\n ignored_paths = [p for p in other_paths if p not in specified_subsets]\n if ignored_paths:\n advice = \"Set --combine-val to combine them or --ignore-unused-valid-subsets to ignore them.\"\n msg = f\"Valid paths {ignored_paths} will be ignored. {advice}\"\n raise ValueError(msg)"},"implementation":{"kind":"string","value":"def batch_by_size(\n indices,\n num_tokens_fn,\n num_tokens_vec=None,\n max_tokens=None,\n max_sentences=None,\n required_batch_size_multiple=1,\n fixed_shapes=None,\n):\n \"\"\"\n Yield mini-batches of indices bucketed by size. Batches may contain\n sequences of different lengths.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n num_tokens_fn (callable): function that returns the number of tokens at\n a given index\n num_tokens_vec (List[int], optional): precomputed vector of the number\n of tokens for each index in indices (to enable faster batch generation)\n max_tokens (int, optional): max number of tokens in each batch\n (default: None).\n max_sentences (int, optional): max number of sentences in each\n batch (default: None).\n required_batch_size_multiple (int, optional): require batch size to\n be less than N or a multiple of N (default: 1).\n fixed_shapes (List[Tuple[int, int]], optional): if given, batches will\n only be created with the given shapes. *max_sentences* and\n *required_batch_size_multiple* will be ignored (default: None).\n \"\"\"\n try:\n from fairseq.data.data_utils_fast import (\n batch_by_size_fn,\n batch_by_size_vec,\n batch_fixed_shapes_fast,\n )\n except ImportError:\n raise ImportError(\n \"Please build Cython components with: \"\n \"`python setup.py build_ext --inplace`\"\n )\n except ValueError:\n raise ValueError(\n \"Please build (or rebuild) Cython components with `python setup.py build_ext --inplace`.\"\n )\n\n # added int() to avoid TypeError: an integer is required\n max_tokens = int(max_tokens) if max_tokens is not None else -1\n max_sentences = max_sentences if max_sentences is not None else -1\n bsz_mult = required_batch_size_multiple\n\n if not isinstance(indices, np.ndarray):\n indices = np.fromiter(indices, dtype=np.int64, count=-1)\n\n if num_tokens_vec is not None and not isinstance(num_tokens_vec, np.ndarray):\n num_tokens_vec = np.fromiter(num_tokens_vec, dtype=np.int64, count=-1)\n\n if fixed_shapes is None:\n if num_tokens_vec is None:\n return batch_by_size_fn(\n indices,\n num_tokens_fn,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n else:\n return batch_by_size_vec(\n indices,\n num_tokens_vec,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n\n else:\n fixed_shapes = np.array(fixed_shapes, dtype=np.int64)\n sort_order = np.lexsort(\n [\n fixed_shapes[:, 1].argsort(), # length\n fixed_shapes[:, 0].argsort(), # bsz\n ]\n )\n fixed_shapes_sorted = fixed_shapes[sort_order]\n return batch_fixed_shapes_fast(indices, num_tokens_fn, fixed_shapes_sorted)"},"start_line":{"kind":"number","value":282,"string":"282"},"end_line":{"kind":"number","value":365,"string":"365"},"file_content":{"kind":"string","value":"# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\ntry:\n from collections.abc import Iterable\nexcept ImportError:\n from collections import Iterable\nimport contextlib\nimport itertools\nimport logging\nimport re\nimport warnings\nfrom typing import Optional, Tuple\n\nimport numpy as np\nimport torch\n\nfrom fairseq.file_io import PathManager\nfrom fairseq import utils\nimport os\n\nlogger = logging.getLogger(__name__)\n\n\ndef infer_language_pair(path):\n \"\"\"Infer language pair from filename: <split>.<lang1>-<lang2>.(...).idx\"\"\"\n src, dst = None, None\n for filename in PathManager.ls(path):\n parts = filename.split(\".\")\n if len(parts) >= 3 and len(parts[1].split(\"-\")) == 2:\n return parts[1].split(\"-\")\n return src, dst\n\n\ndef collate_tokens(\n values,\n pad_idx,\n eos_idx=None,\n left_pad=False,\n move_eos_to_beginning=False,\n pad_to_length=None,\n pad_to_multiple=1,\n pad_to_bsz=None,\n):\n \"\"\"Convert a list of 1d tensors into a padded 2d tensor.\"\"\"\n size = max(v.size(0) for v in values)\n size = size if pad_to_length is None else max(size, pad_to_length)\n if pad_to_multiple != 1 and size % pad_to_multiple != 0:\n size = int(((size - 0.1) // pad_to_multiple + 1) * pad_to_multiple)\n\n batch_size = len(values) if pad_to_bsz is None else max(len(values), pad_to_bsz)\n res = values[0].new(batch_size, size).fill_(pad_idx)\n\n def copy_tensor(src, dst):\n assert dst.numel() == src.numel()\n if move_eos_to_beginning:\n if eos_idx is None:\n # if no eos_idx is specified, then use the last token in src\n dst[0] = src[-1]\n else:\n dst[0] = eos_idx\n dst[1:] = src[:-1]\n else:\n dst.copy_(src)\n\n for i, v in enumerate(values):\n copy_tensor(v, res[i][size - len(v) :] if left_pad else res[i][: len(v)])\n return res\n\n\ndef load_indexed_dataset(\n path, dictionary=None, dataset_impl=None, combine=False, default=\"cached\"\n):\n \"\"\"A helper function for loading indexed datasets.\n\n Args:\n path (str): path to indexed dataset (e.g., 'data-bin/train')\n dictionary (~fairseq.data.Dictionary): data dictionary\n dataset_impl (str, optional): which dataset implementation to use. If\n not provided, it will be inferred automatically. For legacy indexed\n data we use the 'cached' implementation by default.\n combine (bool, optional): automatically load and combine multiple\n datasets. For example, if *path* is 'data-bin/train', then we will\n combine 'data-bin/train', 'data-bin/train1', ... and return a\n single ConcatDataset instance.\n \"\"\"\n import fairseq.data.indexed_dataset as indexed_dataset\n from fairseq.data.concat_dataset import ConcatDataset\n\n datasets = []\n for k in itertools.count():\n path_k = path + (str(k) if k > 0 else \"\")\n try:\n path_k = indexed_dataset.get_indexed_dataset_to_local(path_k)\n except Exception as e:\n if \"StorageException: [404] Path not found\" in str(e):\n logger.warning(f\"path_k: {e} not found\")\n else:\n raise e\n\n dataset_impl_k = dataset_impl\n if dataset_impl_k is None:\n dataset_impl_k = indexed_dataset.infer_dataset_impl(path_k)\n dataset = indexed_dataset.make_dataset(\n path_k,\n impl=dataset_impl_k or default,\n fix_lua_indexing=True,\n dictionary=dictionary,\n )\n if dataset is None:\n break\n logger.info(\"loaded {:,} examples from: {}\".format(len(dataset), path_k))\n datasets.append(dataset)\n if not combine:\n break\n if len(datasets) == 0:\n return None\n elif len(datasets) == 1:\n return datasets[0]\n else:\n return ConcatDataset(datasets)\n\n\n@contextlib.contextmanager\ndef numpy_seed(seed, *addl_seeds):\n \"\"\"Context manager which seeds the NumPy PRNG with the specified seed and\n restores the state afterward\"\"\"\n if seed is None:\n yield\n return\n if len(addl_seeds) > 0:\n seed = int(hash((seed, *addl_seeds)) % 1e6)\n state = np.random.get_state()\n np.random.seed(seed)\n try:\n yield\n finally:\n np.random.set_state(state)\n\n\ndef collect_filtered(function, iterable, filtered):\n \"\"\"\n Similar to :func:`filter` but collects filtered elements in ``filtered``.\n\n Args:\n function (callable): function that returns ``False`` for elements that\n should be filtered\n iterable (iterable): iterable to filter\n filtered (list): list to store filtered elements\n \"\"\"\n for el in iterable:\n if function(el):\n yield el\n else:\n filtered.append(el)\n\n\ndef _filter_by_size_dynamic(indices, size_fn, max_positions, raise_exception=False):\n def compare_leq(a, b):\n return a <= b if not isinstance(a, tuple) else max(a) <= b\n\n def check_size(idx):\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n return size_fn(idx) <= max_positions\n elif isinstance(max_positions, dict):\n idx_size = size_fn(idx)\n assert isinstance(idx_size, dict)\n intersect_keys = set(max_positions.keys()) & set(idx_size.keys())\n return all(\n all(\n a is None or b is None or a <= b\n for a, b in zip(idx_size[key], max_positions[key])\n )\n for key in intersect_keys\n )\n else:\n # For MultiCorpusSampledDataset, will generalize it later\n if not isinstance(size_fn(idx), Iterable):\n return all(size_fn(idx) <= b for b in max_positions)\n return all(\n a is None or b is None or a <= b\n for a, b in zip(size_fn(idx), max_positions)\n )\n\n ignored = []\n itr = collect_filtered(check_size, indices, ignored)\n indices = np.fromiter(itr, dtype=np.int64, count=-1)\n return indices, ignored\n\n\ndef filter_by_size(indices, dataset, max_positions, raise_exception=False):\n \"\"\"\n [deprecated] Filter indices based on their size.\n Use `FairseqDataset::filter_indices_by_size` instead.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n dataset (FairseqDataset): fairseq dataset instance\n max_positions (tuple): filter elements larger than this size.\n Comparisons are done component-wise.\n raise_exception (bool, optional): if ``True``, raise an exception if\n any elements are filtered (default: False).\n \"\"\"\n warnings.warn(\n \"data_utils.filter_by_size is deprecated. \"\n \"Use `FairseqDataset::filter_indices_by_size` instead.\",\n stacklevel=2,\n )\n if isinstance(max_positions, float) or isinstance(max_positions, int):\n if hasattr(dataset, \"sizes\") and isinstance(dataset.sizes, np.ndarray):\n ignored = indices[dataset.sizes[indices] > max_positions].tolist()\n indices = indices[dataset.sizes[indices] <= max_positions]\n elif (\n hasattr(dataset, \"sizes\")\n and isinstance(dataset.sizes, list)\n and len(dataset.sizes) == 1\n ):\n ignored = indices[dataset.sizes[0][indices] > max_positions].tolist()\n indices = indices[dataset.sizes[0][indices] <= max_positions]\n else:\n indices, ignored = _filter_by_size_dynamic(\n indices, dataset.size, max_positions\n )\n else:\n indices, ignored = _filter_by_size_dynamic(indices, dataset.size, max_positions)\n\n if len(ignored) > 0 and raise_exception:\n raise Exception(\n (\n \"Size of sample #{} is invalid (={}) since max_positions={}, \"\n \"skip this example with --skip-invalid-size-inputs-valid-test\"\n ).format(ignored[0], dataset.size(ignored[0]), max_positions)\n )\n if len(ignored) > 0:\n logger.warning(\n (\n \"{} samples have invalid sizes and will be skipped, \"\n \"max_positions={}, first few sample ids={}\"\n ).format(len(ignored), max_positions, ignored[:10])\n )\n return indices\n\n\ndef filter_paired_dataset_indices_by_size(src_sizes, tgt_sizes, indices, max_sizes):\n \"\"\"Filter a list of sample indices. Remove those that are longer\n than specified in max_sizes.\n\n Args:\n indices (np.array): original array of sample indices\n max_sizes (int or list[int] or tuple[int]): max sample size,\n can be defined separately for src and tgt (then list or tuple)\n\n Returns:\n np.array: filtered sample array\n list: list of removed indices\n \"\"\"\n if max_sizes is None:\n return indices, []\n if type(max_sizes) in (int, float):\n max_src_size, max_tgt_size = max_sizes, max_sizes\n else:\n max_src_size, max_tgt_size = max_sizes\n if tgt_sizes is None:\n ignored = indices[src_sizes[indices] > max_src_size]\n else:\n ignored = indices[\n (src_sizes[indices] > max_src_size) | (tgt_sizes[indices] > max_tgt_size)\n ]\n if len(ignored) > 0:\n if tgt_sizes is None:\n indices = indices[src_sizes[indices] <= max_src_size]\n else:\n indices = indices[\n (src_sizes[indices] <= max_src_size)\n & (tgt_sizes[indices] <= max_tgt_size)\n ]\n return indices, ignored.tolist()\n\n\ndef batch_by_size(\n indices,\n num_tokens_fn,\n num_tokens_vec=None,\n max_tokens=None,\n max_sentences=None,\n required_batch_size_multiple=1,\n fixed_shapes=None,\n):\n \"\"\"\n Yield mini-batches of indices bucketed by size. Batches may contain\n sequences of different lengths.\n\n Args:\n indices (List[int]): ordered list of dataset indices\n num_tokens_fn (callable): function that returns the number of tokens at\n a given index\n num_tokens_vec (List[int], optional): precomputed vector of the number\n of tokens for each index in indices (to enable faster batch generation)\n max_tokens (int, optional): max number of tokens in each batch\n (default: None).\n max_sentences (int, optional): max number of sentences in each\n batch (default: None).\n required_batch_size_multiple (int, optional): require batch size to\n be less than N or a multiple of N (default: 1).\n fixed_shapes (List[Tuple[int, int]], optional): if given, batches will\n only be created with the given shapes. *max_sentences* and\n *required_batch_size_multiple* will be ignored (default: None).\n \"\"\"\n try:\n from fairseq.data.data_utils_fast import (\n batch_by_size_fn,\n batch_by_size_vec,\n batch_fixed_shapes_fast,\n )\n except ImportError:\n raise ImportError(\n \"Please build Cython components with: \"\n \"`python setup.py build_ext --inplace`\"\n )\n except ValueError:\n raise ValueError(\n \"Please build (or rebuild) Cython components with `python setup.py build_ext --inplace`.\"\n )\n\n # added int() to avoid TypeError: an integer is required\n max_tokens = int(max_tokens) if max_tokens is not None else -1\n max_sentences = max_sentences if max_sentences is not None else -1\n bsz_mult = required_batch_size_multiple\n\n if not isinstance(indices, np.ndarray):\n indices = np.fromiter(indices, dtype=np.int64, count=-1)\n\n if num_tokens_vec is not None and not isinstance(num_tokens_vec, np.ndarray):\n num_tokens_vec = np.fromiter(num_tokens_vec, dtype=np.int64, count=-1)\n\n if fixed_shapes is None:\n if num_tokens_vec is None:\n return batch_by_size_fn(\n indices,\n num_tokens_fn,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n else:\n return batch_by_size_vec(\n indices,\n num_tokens_vec,\n max_tokens,\n max_sentences,\n bsz_mult,\n )\n\n else:\n fixed_shapes = np.array(fixed_shapes, dtype=np.int64)\n sort_order = np.lexsort(\n [\n fixed_shapes[:, 1].argsort(), # length\n fixed_shapes[:, 0].argsort(), # bsz\n ]\n )\n fixed_shapes_sorted = fixed_shapes[sort_order]\n return batch_fixed_shapes_fast(indices, num_tokens_fn, fixed_shapes_sorted)\n\n\ndef post_process(sentence: str, symbol: str):\n if symbol == \"sentencepiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"\\u2581\", \" \").strip()\n elif symbol == \"wordpiece\":\n sentence = sentence.replace(\" \", \"\").replace(\"_\", \" \").strip()\n elif symbol == \"letter\":\n sentence = sentence.replace(\" \", \"\").replace(\"|\", \" \").strip()\n elif symbol == \"silence\":\n import re\n\n sentence = sentence.replace(\"<SIL>\", \"\")\n sentence = re.sub(\" +\", \" \", sentence).strip()\n elif symbol == \"_EOW\":\n sentence = sentence.replace(\" \", \"\").replace(\"_EOW\", \" \").strip()\n elif symbol in {\"subword_nmt\", \"@@ \", \"@@\"}:\n if symbol == \"subword_nmt\":\n symbol = \"@@ \"\n sentence = (sentence + \" \").replace(symbol, \"\").rstrip()\n elif symbol == \"none\":\n pass\n elif symbol is not None:\n raise NotImplementedError(f\"Unknown post_process option: {symbol}\")\n return sentence\n\n\ndef compute_mask_indices(\n shape: Tuple[int, int],\n padding_mask: Optional[torch.Tensor],\n mask_prob: float,\n mask_length: int,\n mask_type: str = \"static\",\n mask_other: float = 0.0,\n min_masks: int = 0,\n no_overlap: bool = False,\n min_space: int = 0,\n) -> np.ndarray:\n \"\"\"\n Computes random mask spans for a given shape\n\n Args:\n shape: the the shape for which to compute masks.\n should be of size 2 where first element is batch size and 2nd is timesteps\n padding_mask: optional padding mask of the same size as shape, which will prevent masking padded elements\n mask_prob: probability for each token to be chosen as start of the span to be masked. this will be multiplied by\n number of timesteps divided by length of mask span to mask approximately this percentage of all elements.\n however due to overlaps, the actual number will be smaller (unless no_overlap is True)\n mask_type: how to compute mask lengths\n static = fixed size\n uniform = sample from uniform distribution [mask_other, mask_length*2]\n normal = sample from normal distribution with mean mask_length and stdev mask_other. mask is min 1 element\n poisson = sample from possion distribution with lambda = mask length\n min_masks: minimum number of masked spans\n no_overlap: if false, will switch to an alternative recursive algorithm that prevents spans from overlapping\n min_space: only used if no_overlap is True, this is how many elements to keep unmasked between spans\n \"\"\"\n\n bsz, all_sz = shape\n mask = np.full((bsz, all_sz), False)\n\n all_num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * all_sz / float(mask_length)\n + np.random.rand()\n )\n\n all_num_mask = max(min_masks, all_num_mask)\n\n mask_idcs = []\n for i in range(bsz):\n if padding_mask is not None:\n sz = all_sz - padding_mask[i].long().sum().item()\n num_mask = int(\n # add a random number for probabilistic rounding\n mask_prob * sz / float(mask_length)\n + np.random.rand()\n )\n num_mask = max(min_masks, num_mask)\n else:\n sz = all_sz\n num_mask = all_num_mask\n\n if mask_type == \"static\":\n lengths = np.full(num_mask, mask_length)\n elif mask_type == \"uniform\":\n lengths = np.random.randint(mask_other, mask_length * 2 + 1, size=num_mask)\n elif mask_type == \"normal\":\n lengths = np.random.normal(mask_length, mask_other, size=num_mask)\n lengths = [max(1, int(round(x))) for x in lengths]\n elif mask_type == \"poisson\":\n lengths = np.random.poisson(mask_length, size=num_mask)\n lengths = [int(round(x)) for x in lengths]\n else:\n raise Exception(\"unknown mask selection \" + mask_type)\n\n if sum(lengths) == 0:\n lengths[0] = min(mask_length, sz - 1)\n\n if no_overlap:\n mask_idc = []\n\n def arrange(s, e, length, keep_length):\n span_start = np.random.randint(s, e - length)\n mask_idc.extend(span_start + i for i in range(length))\n\n new_parts = []\n if span_start - s - min_space >= keep_length:\n new_parts.append((s, span_start - min_space + 1))\n if e - span_start - keep_length - min_space > keep_length:\n new_parts.append((span_start + length + min_space, e))\n return new_parts\n\n parts = [(0, sz)]\n min_length = min(lengths)\n for length in sorted(lengths, reverse=True):\n lens = np.fromiter(\n (e - s if e - s >= length + min_space else 0 for s, e in parts),\n np.int,\n )\n l_sum = np.sum(lens)\n if l_sum == 0:\n break\n probs = lens / np.sum(lens)\n c = np.random.choice(len(parts), p=probs)\n s, e = parts.pop(c)\n parts.extend(arrange(s, e, length, min_length))\n mask_idc = np.asarray(mask_idc)\n else:\n min_len = min(lengths)\n if sz - min_len <= num_mask:\n min_len = sz - num_mask - 1\n\n mask_idc = np.random.choice(sz - min_len, num_mask, replace=False)\n\n mask_idc = np.asarray(\n [\n mask_idc[j] + offset\n for j in range(len(mask_idc))\n for offset in range(lengths[j])\n ]\n )\n\n mask_idcs.append(np.unique(mask_idc[mask_idc < sz]))\n\n min_len = min([len(m) for m in mask_idcs])\n for i, mask_idc in enumerate(mask_idcs):\n if len(mask_idc) > min_len:\n mask_idc = np.random.choice(mask_idc, min_len, replace=False)\n mask[i, mask_idc] = True\n\n return mask\n\n\ndef get_mem_usage():\n try:\n import psutil\n\n mb = 1024 * 1024\n return f\"used={psutil.virtual_memory().used / mb}Mb; avail={psutil.virtual_memory().available / mb}Mb\"\n except ImportError:\n return \"N/A\"\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_padding_mask(lens):\n bsz, max_lens = lens.size(0), torch.max(lens).item()\n mask = torch.arange(max_lens).to(lens.device).view(1, max_lens)\n mask = mask.expand(bsz, -1) >= lens.view(bsz, 1).expand(-1, max_lens)\n return mask\n\n\n# lens: torch.LongTensor\n# returns: torch.BoolTensor\ndef lengths_to_mask(lens):\n return ~lengths_to_padding_mask(lens)\n\n\ndef get_buckets(sizes, num_buckets):\n buckets = np.unique(\n np.percentile(\n sizes,\n np.linspace(0, 100, num_buckets + 1),\n interpolation=\"lower\",\n )[1:]\n )\n return buckets\n\n\ndef get_bucketed_sizes(orig_sizes, buckets):\n sizes = np.copy(orig_sizes)\n assert np.min(sizes) >= 0\n start_val = -1\n for end_val in buckets:\n mask = (sizes > start_val) & (sizes <= end_val)\n sizes[mask] = end_val\n start_val = end_val\n return sizes\n\n\ndef _find_extra_valid_paths(dataset_path: str) -> set:\n paths = utils.split_paths(dataset_path)\n all_valid_paths = set()\n for sub_dir in paths:\n contents = PathManager.ls(sub_dir)\n valid_paths = [c for c in contents if re.match(\"valid*[0-9].*\", c) is not None]\n all_valid_paths |= {os.path.basename(p) for p in valid_paths}\n # Remove .bin, .idx etc\n roots = {os.path.splitext(p)[0] for p in all_valid_paths}\n return roots\n\n\ndef raise_if_valid_subsets_unintentionally_ignored(train_cfg) -> None:\n \"\"\"Raises if there are paths matching 'valid*[0-9].*' which are not combined or ignored.\"\"\"\n if (\n train_cfg.dataset.ignore_unused_valid_subsets\n or train_cfg.dataset.combine_valid_subsets\n or train_cfg.dataset.disable_validation\n or not hasattr(train_cfg.task, \"data\")\n ):\n return\n other_paths = _find_extra_valid_paths(train_cfg.task.data)\n specified_subsets = train_cfg.dataset.valid_subset.split(\",\")\n ignored_paths = [p for p in other_paths if p not in specified_subsets]\n if ignored_paths:\n advice = \"Set --combine-val to combine them or --ignore-unused-valid-subsets to ignore them.\"\n msg = f\"Valid paths {ignored_paths} will be ignored. {advice}\"\n raise ValueError(msg)\n"}}},{"rowIdx":2072,"cells":{"function_name":{"kind":"string","value":"main"},"docstring":{"kind":"string","value":"Process command line arguments and invoke bot.\n\nIf args is an empty list, sys.argv is used.\n\n@param args: command line arguments\n@type args: str"},"masked_code":{"kind":"string","value":"#!/usr/bin/python\n# -*- coding: utf-8 -*-\n\"\"\"\nScript to upload the mappings of Freebase to Wikidata.\n\nCan be easily adapted to upload other String identifiers as well\n\nThis bot needs the dump from\nhttps://developers.google.com/freebase/data#freebase-wikidata-mappings\n\nThe script takes a single parameter:\n\n-filename: the filename to read the freebase-wikidata mappings from;\n default: fb2w.nt.gz\n\"\"\"\n#\n# (C) Denny Vrandecic, 2013\n# (C) Pywikibot team, 2013-2018\n#\n# Distributed under the terms of the MIT license.\n#\nfrom __future__ import absolute_import, division, unicode_literals\n\nimport gzip\nimport os\nimport sys\n\nimport pywikibot\n\n\nclass FreebaseMapperRobot(object):\n\n \"\"\"Freebase Mapping bot.\"\"\"\n\n def __init__(self, filename):\n \"\"\"Initializer.\"\"\"\n self.repo = pywikibot.Site('wikidata', 'wikidata').data_repository()\n self.filename = filename\n if not os.path.exists(self.filename):\n pywikibot.output('Cannot find %s. Try providing the absolute path.'\n % self.filename)\n sys.exit(1)\n\n def run(self):\n \"\"\"Run the bot.\"\"\"\n # Set up some items we will use a lot.\n self.claim = pywikibot.Claim(self.repo, 'P646') # freebase mapping\n # And sources!\n self.statedin = pywikibot.Claim(self.repo, 'P248') # stated in\n # Freebase data dump\n freebasedumpitem = pywikibot.ItemPage(self.repo, 'Q15241312')\n self.statedin.setTarget(freebasedumpitem)\n # date of publication\n self.dateofpub = pywikibot.Claim(self.repo, 'P577')\n oct28 = pywikibot.WbTime(site=self.repo, year=2013, month=10, day=28,\n precision='day')\n self.dateofpub.setTarget(oct28)\n\n for line in gzip.open(self.filename):\n self.processLine(line.strip())\n\n def processLine(self, line):\n \"\"\"Process a single line.\"\"\"\n if not line or line.startswith('#'):\n return\n mid, sameas, qid, dot = line.split()\n if sameas != '<https://www.w3.org/2002/07/owl#sameAs>':\n return\n if dot != '.':\n return\n if not mid.startswith('<https://rdf.freebase.com/ns/m'):\n return\n mid = '/m/' + mid[30:-1]\n if not qid.startswith('<https://www.wikidata.org/entity/Q'):\n return\n qid = 'Q' + qid[33:-1]\n data = pywikibot.ItemPage(self.repo, qid)\n data.get()\n if not data.labels:\n label = ''\n elif 'en' in data.labels:\n label = data.labels['en']\n else:\n # Just pick up the first label\n label = list(data.labels.values())[0]\n pywikibot.output('Parsed: {} <--> {}'.format(qid, mid))\n pywikibot.output('{} is {}'.format(data.getID(), label))\n if data.claims and 'P646' in data.claims:\n # We assume that there is only one claim.\n # If there are multiple ones, our logs might be wrong\n # but the constraint value reports will catch them\n if mid != data.claims['P646'][0].getTarget():\n pywikibot.output('Mismatch: expected {}, has {} instead'\n .format(mid,\n data.claims['P646'][0].getTarget()))\n else:\n pywikibot.output('Already has mid set, is consistent.')\n else:\n # No claim set, lets add it.\n pywikibot.output('Going to add a new claim.')\n self.claim.setTarget(mid)\n data.addClaim(self.claim)\n self.claim.addSources([self.statedin, self.dateofpub])\n pywikibot.output('Claim added!')\n\n\n# MASKED: main function (lines 107-121)\n\n\nif __name__ == '__main__':\n main()"},"implementation":{"kind":"string","value":"def main(*args):\n \"\"\"\n Process command line arguments and invoke bot.\n\n If args is an empty list, sys.argv is used.\n\n @param args: command line arguments\n @type args: str\n \"\"\"\n filename = 'fb2w.nt.gz' # Default filename\n for arg in pywikibot.handle_args(args):\n if arg.startswith('-filename'):\n filename = arg[11:]\n bot = FreebaseMapperRobot(filename)\n bot.run()"},"start_line":{"kind":"number","value":107,"string":"107"},"end_line":{"kind":"number","value":121,"string":"121"},"file_content":{"kind":"string","value":"#!/usr/bin/python\n# -*- coding: utf-8 -*-\n\"\"\"\nScript to upload the mappings of Freebase to Wikidata.\n\nCan be easily adapted to upload other String identifiers as well\n\nThis bot needs the dump from\nhttps://developers.google.com/freebase/data#freebase-wikidata-mappings\n\nThe script takes a single parameter:\n\n-filename: the filename to read the freebase-wikidata mappings from;\n default: fb2w.nt.gz\n\"\"\"\n#\n# (C) Denny Vrandecic, 2013\n# (C) Pywikibot team, 2013-2018\n#\n# Distributed under the terms of the MIT license.\n#\nfrom __future__ import absolute_import, division, unicode_literals\n\nimport gzip\nimport os\nimport sys\n\nimport pywikibot\n\n\nclass FreebaseMapperRobot(object):\n\n \"\"\"Freebase Mapping bot.\"\"\"\n\n def __init__(self, filename):\n \"\"\"Initializer.\"\"\"\n self.repo = pywikibot.Site('wikidata', 'wikidata').data_repository()\n self.filename = filename\n if not os.path.exists(self.filename):\n pywikibot.output('Cannot find %s. Try providing the absolute path.'\n % self.filename)\n sys.exit(1)\n\n def run(self):\n \"\"\"Run the bot.\"\"\"\n # Set up some items we will use a lot.\n self.claim = pywikibot.Claim(self.repo, 'P646') # freebase mapping\n # And sources!\n self.statedin = pywikibot.Claim(self.repo, 'P248') # stated in\n # Freebase data dump\n freebasedumpitem = pywikibot.ItemPage(self.repo, 'Q15241312')\n self.statedin.setTarget(freebasedumpitem)\n # date of publication\n self.dateofpub = pywikibot.Claim(self.repo, 'P577')\n oct28 = pywikibot.WbTime(site=self.repo, year=2013, month=10, day=28,\n precision='day')\n self.dateofpub.setTarget(oct28)\n\n for line in gzip.open(self.filename):\n self.processLine(line.strip())\n\n def processLine(self, line):\n \"\"\"Process a single line.\"\"\"\n if not line or line.startswith('#'):\n return\n mid, sameas, qid, dot = line.split()\n if sameas != '<https://www.w3.org/2002/07/owl#sameAs>':\n return\n if dot != '.':\n return\n if not mid.startswith('<https://rdf.freebase.com/ns/m'):\n return\n mid = '/m/' + mid[30:-1]\n if not qid.startswith('<https://www.wikidata.org/entity/Q'):\n return\n qid = 'Q' + qid[33:-1]\n data = pywikibot.ItemPage(self.repo, qid)\n data.get()\n if not data.labels:\n label = ''\n elif 'en' in data.labels:\n label = data.labels['en']\n else:\n # Just pick up the first label\n label = list(data.labels.values())[0]\n pywikibot.output('Parsed: {} <--> {}'.format(qid, mid))\n pywikibot.output('{} is {}'.format(data.getID(), label))\n if data.claims and 'P646' in data.claims:\n # We assume that there is only one claim.\n # If there are multiple ones, our logs might be wrong\n # but the constraint value reports will catch them\n if mid != data.claims['P646'][0].getTarget():\n pywikibot.output('Mismatch: expected {}, has {} instead'\n .format(mid,\n data.claims['P646'][0].getTarget()))\n else:\n pywikibot.output('Already has mid set, is consistent.')\n else:\n # No claim set, lets add it.\n pywikibot.output('Going to add a new claim.')\n self.claim.setTarget(mid)\n data.addClaim(self.claim)\n self.claim.addSources([self.statedin, self.dateofpub])\n pywikibot.output('Claim added!')\n\n\ndef main(*args):\n \"\"\"\n Process command line arguments and invoke bot.\n\n If args is an empty list, sys.argv is used.\n\n @param args: command line arguments\n @type args: str\n \"\"\"\n filename = 'fb2w.nt.gz' # Default filename\n for arg in pywikibot.handle_args(args):\n if arg.startswith('-filename'):\n filename = arg[11:]\n bot = FreebaseMapperRobot(filename)\n bot.run()\n\n\nif __name__ == '__main__':\n main()\n"}}},{"rowIdx":2073,"cells":{"function_name":{"kind":"string","value":"run"},"docstring":{"kind":"string","value":"On purpose this doesn't call the ObjectDescription version, but is based on it.\nEach alias signature may expand into multiple real signatures (an overload set).\nThe code is therefore based on the ObjectDescription version."},"masked_code":{"kind":"string","value":"\"\"\"\n sphinx.domains.cpp\n ~~~~~~~~~~~~~~~~~~\n\n The C++ language domain.\n\n :copyright: Copyright 2007-2020 by the Sphinx team, see AUTHORS.\n :license: BSD, see LICENSE for details.\n\"\"\"\n\nimport re\nfrom typing import (\n Any, Callable, Dict, Generator, Iterator, List, Tuple, Type, TypeVar, Union\n)\n\nfrom docutils import nodes\nfrom docutils.nodes import Element, Node, TextElement, system_message\nfrom docutils.parsers.rst import directives\n\nfrom sphinx import addnodes\nfrom sphinx.addnodes import desc_signature, pending_xref\nfrom sphinx.application import Sphinx\nfrom sphinx.builders import Builder\nfrom sphinx.directives import ObjectDescription\nfrom sphinx.domains import Domain, ObjType\nfrom sphinx.environment import BuildEnvironment\nfrom sphinx.errors import NoUri\nfrom sphinx.locale import _, __\nfrom sphinx.roles import SphinxRole, XRefRole\nfrom sphinx.transforms import SphinxTransform\nfrom sphinx.transforms.post_transforms import ReferencesResolver\nfrom sphinx.util import logging\nfrom sphinx.util.cfamily import (\n NoOldIdError, ASTBaseBase, ASTAttribute, verify_description_mode, StringifyTransform,\n BaseParser, DefinitionError, UnsupportedMultiCharacterCharLiteral,\n identifier_re, anon_identifier_re, integer_literal_re, octal_literal_re,\n hex_literal_re, binary_literal_re, float_literal_re,\n char_literal_re\n)\nfrom sphinx.util.docfields import Field, GroupedField\nfrom sphinx.util.docutils import SphinxDirective\nfrom sphinx.util.nodes import make_refnode\n\n\nlogger = logging.getLogger(__name__)\nT = TypeVar('T')\n\n\"\"\"\n Important note on ids\n ----------------------------------------------------------------------------\n\n Multiple id generation schemes are used due to backwards compatibility.\n - v1: 1.2.3 <= version < 1.3\n The style used before the rewrite.\n It is not the actual old code, but a replication of the behaviour.\n - v2: 1.3 <= version < now\n Standardised mangling scheme from\n https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling\n though not completely implemented.\n All versions are generated and attached to elements. The newest is used for\n the index. All of the versions should work as permalinks.\n\n\n Signature Nodes and Tagnames\n ----------------------------------------------------------------------------\n\n Each signature is in a desc_signature node, where all children are\n desc_signature_line nodes. Each of these lines will have the attribute\n 'sphinx_line_type' set to one of the following (prioritized):\n - 'declarator', if the line contains the name of the declared object.\n - 'templateParams', if the line starts a template parameter list,\n - 'templateParams', if the line has template parameters\n Note: such lines might get a new tag in the future.\n - 'templateIntroduction, if the line is on the form 'conceptName{...}'\n No other desc_signature nodes should exist (so far).\n\n\n Grammar\n ----------------------------------------------------------------------------\n\n See https://www.nongnu.org/hcb/ for the grammar,\n and https://github.com/cplusplus/draft/blob/master/source/grammar.tex,\n and https://github.com/cplusplus/concepts-ts\n for the newest grammar.\n\n common grammar things:\n template-declaration ->\n \"template\" \"<\" template-parameter-list \">\" declaration\n template-parameter-list ->\n template-parameter\n | template-parameter-list \",\" template-parameter\n template-parameter ->\n type-parameter\n | parameter-declaration # i.e., same as a function argument\n\n type-parameter ->\n \"class\" \"...\"[opt] identifier[opt]\n | \"class\" identifier[opt] \"=\" type-id\n | \"typename\" \"...\"[opt] identifier[opt]\n | \"typename\" identifier[opt] \"=\" type-id\n | \"template\" \"<\" template-parameter-list \">\"\n \"class\" \"...\"[opt] identifier[opt]\n | \"template\" \"<\" template-parameter-list \">\"\n \"class\" identifier[opt] \"=\" id-expression\n # also, from C++17 we can have \"typename\" in template templates\n templateDeclPrefix ->\n \"template\" \"<\" template-parameter-list \">\"\n\n simple-declaration ->\n attribute-specifier-seq[opt] decl-specifier-seq[opt]\n init-declarator-list[opt] ;\n # Drop the semi-colon. For now: drop the attributes (TODO).\n # Use at most 1 init-declarator.\n -> decl-specifier-seq init-declarator\n -> decl-specifier-seq declarator initializer\n\n decl-specifier ->\n storage-class-specifier ->\n ( \"static\" (only for member_object and function_object)\n | \"extern\" (only for member_object and function_object)\n | \"register\"\n )\n thread_local[opt] (only for member_object)\n (it can also appear before the others)\n\n | type-specifier -> trailing-type-specifier\n | function-specifier -> \"inline\" | \"virtual\" | \"explicit\" (only\n for function_object)\n | \"friend\" (only for function_object)\n | \"constexpr\" (only for member_object and function_object)\n trailing-type-specifier ->\n simple-type-specifier\n | elaborated-type-specifier\n | typename-specifier\n | cv-qualifier -> \"const\" | \"volatile\"\n stricter grammar for decl-specifier-seq (with everything, each object\n uses a subset):\n visibility storage-class-specifier function-specifier \"friend\"\n \"constexpr\" \"volatile\" \"const\" trailing-type-specifier\n # where trailing-type-specifier can no be cv-qualifier\n # Inside e.g., template paramters a strict subset is used\n # (see type-specifier-seq)\n trailing-type-specifier ->\n simple-type-specifier ->\n ::[opt] nested-name-specifier[opt] type-name\n | ::[opt] nested-name-specifier \"template\" simple-template-id\n | \"char\" | \"bool\" | ect.\n | decltype-specifier\n | elaborated-type-specifier ->\n class-key attribute-specifier-seq[opt] ::[opt]\n nested-name-specifier[opt] identifier\n | class-key ::[opt] nested-name-specifier[opt] template[opt]\n simple-template-id\n | \"enum\" ::[opt] nested-name-specifier[opt] identifier\n | typename-specifier ->\n \"typename\" ::[opt] nested-name-specifier identifier\n | \"typename\" ::[opt] nested-name-specifier template[opt]\n simple-template-id\n class-key -> \"class\" | \"struct\" | \"union\"\n type-name ->* identifier | simple-template-id\n # ignoring attributes and decltype, and then some left-factoring\n trailing-type-specifier ->\n rest-of-trailing\n (\"class\" | \"struct\" | \"union\" | \"typename\") rest-of-trailing\n build-in -> \"char\" | \"bool\" | ect.\n decltype-specifier\n rest-of-trailing -> (with some simplification)\n \"::\"[opt] list-of-elements-separated-by-::\n element ->\n \"template\"[opt] identifier (\"<\" template-argument-list \">\")[opt]\n template-argument-list ->\n template-argument \"...\"[opt]\n | template-argument-list \",\" template-argument \"...\"[opt]\n template-argument ->\n constant-expression\n | type-specifier-seq abstract-declarator\n | id-expression\n\n\n declarator ->\n ptr-declarator\n | noptr-declarator parameters-and-qualifiers trailing-return-type\n (TODO: for now we don't support trailing-eturn-type)\n ptr-declarator ->\n noptr-declarator\n | ptr-operator ptr-declarator\n noptr-declarator ->\n declarator-id attribute-specifier-seq[opt] ->\n \"...\"[opt] id-expression\n | rest-of-trailing\n | noptr-declarator parameters-and-qualifiers\n | noptr-declarator \"[\" constant-expression[opt] \"]\"\n attribute-specifier-seq[opt]\n | \"(\" ptr-declarator \")\"\n ptr-operator ->\n \"*\" attribute-specifier-seq[opt] cv-qualifier-seq[opt]\n | \"& attribute-specifier-seq[opt]\n | \"&&\" attribute-specifier-seq[opt]\n | \"::\"[opt] nested-name-specifier \"*\" attribute-specifier-seq[opt]\n cv-qualifier-seq[opt]\n # function_object must use a parameters-and-qualifiers, the others may\n # use it (e.g., function poitners)\n parameters-and-qualifiers ->\n \"(\" parameter-clause \")\" attribute-specifier-seq[opt]\n cv-qualifier-seq[opt] ref-qualifier[opt]\n exception-specification[opt]\n ref-qualifier -> \"&\" | \"&&\"\n exception-specification ->\n \"noexcept\" (\"(\" constant-expression \")\")[opt]\n \"throw\" (\"(\" type-id-list \")\")[opt]\n # TODO: we don't implement attributes\n # member functions can have initializers, but we fold them into here\n memberFunctionInit -> \"=\" \"0\"\n # (note: only \"0\" is allowed as the value, according to the standard,\n # right?)\n\n enum-head ->\n enum-key attribute-specifier-seq[opt] nested-name-specifier[opt]\n identifier enum-base[opt]\n enum-key -> \"enum\" | \"enum struct\" | \"enum class\"\n enum-base ->\n \":\" type\n enumerator-definition ->\n identifier\n | identifier \"=\" constant-expression\n\n We additionally add the possibility for specifying the visibility as the\n first thing.\n\n concept_object:\n goal:\n just a declaration of the name (for now)\n\n grammar: only a single template parameter list, and the nested name\n may not have any template argument lists\n\n \"template\" \"<\" template-parameter-list \">\"\n nested-name-specifier\n\n type_object:\n goal:\n either a single type (e.g., \"MyClass:Something_T\" or a typedef-like\n thing (e.g. \"Something Something_T\" or \"int I_arr[]\"\n grammar, single type: based on a type in a function parameter, but\n without a name:\n parameter-declaration\n -> attribute-specifier-seq[opt] decl-specifier-seq\n abstract-declarator[opt]\n # Drop the attributes\n -> decl-specifier-seq abstract-declarator[opt]\n grammar, typedef-like: no initilizer\n decl-specifier-seq declarator\n Can start with a templateDeclPrefix.\n\n member_object:\n goal: as a type_object which must have a declarator, and optionally\n with a initializer\n grammar:\n decl-specifier-seq declarator initializer\n Can start with a templateDeclPrefix.\n\n function_object:\n goal: a function declaration, TODO: what about templates? for now: skip\n grammar: no initializer\n decl-specifier-seq declarator\n Can start with a templateDeclPrefix.\n\n class_object:\n goal: a class declaration, but with specification of a base class\n grammar:\n nested-name \"final\"[opt] (\":\" base-specifier-list)[opt]\n base-specifier-list ->\n base-specifier \"...\"[opt]\n | base-specifier-list, base-specifier \"...\"[opt]\n base-specifier ->\n base-type-specifier\n | \"virtual\" access-spe\"cifier[opt] base-type-specifier\n | access-specifier[opt] \"virtual\"[opt] base-type-specifier\n Can start with a templateDeclPrefix.\n\n enum_object:\n goal: an unscoped enum or a scoped enum, optionally with the underlying\n type specified\n grammar:\n (\"class\" | \"struct\")[opt] visibility[opt] nested-name (\":\" type)[opt]\n enumerator_object:\n goal: an element in a scoped or unscoped enum. The name should be\n injected according to the scopedness.\n grammar:\n nested-name (\"=\" constant-expression)\n\n namespace_object:\n goal: a directive to put all following declarations in a specific scope\n grammar:\n nested-name\n\"\"\"\n\n_string_re = re.compile(r\"[LuU8]?('([^'\\\\]*(?:\\\\.[^'\\\\]*)*)'\"\n r'|\"([^\"\\\\]*(?:\\\\.[^\"\\\\]*)*)\")', re.S)\n_visibility_re = re.compile(r'\\b(public|private|protected)\\b')\n_operator_re = re.compile(r'''(?x)\n \\[\\s*\\]\n | \\(\\s*\\)\n | \\+\\+ | --\n | ->\\*? | \\,\n | (<<|>>)=? | && | \\|\\|\n | [!<>=/*%+|&^~-]=?\n | (\\b(and|and_eq|bitand|bitor|compl|not|not_eq|or|or_eq|xor|xor_eq)\\b)\n''')\n_fold_operator_re = re.compile(r'''(?x)\n ->\\* | \\.\\* | \\,\n | (<<|>>)=? | && | \\|\\|\n | !=\n | [<>=/*%+|&^~-]=?\n''')\n# see https://en.cppreference.com/w/cpp/keyword\n_keywords = [\n 'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor',\n 'bool', 'break', 'case', 'catch', 'char', 'char16_t', 'char32_t', 'class',\n 'compl', 'concept', 'const', 'constexpr', 'const_cast', 'continue',\n 'decltype', 'default', 'delete', 'do', 'double', 'dynamic_cast', 'else',\n 'enum', 'explicit', 'export', 'extern', 'false', 'float', 'for', 'friend',\n 'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new',\n 'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq',\n 'private', 'protected', 'public', 'register', 'reinterpret_cast',\n 'requires', 'return', 'short', 'signed', 'sizeof', 'static',\n 'static_assert', 'static_cast', 'struct', 'switch', 'template', 'this',\n 'thread_local', 'throw', 'true', 'try', 'typedef', 'typeid', 'typename',\n 'union', 'unsigned', 'using', 'virtual', 'void', 'volatile', 'wchar_t',\n 'while', 'xor', 'xor_eq'\n]\n\n_max_id = 4\n_id_prefix = [None, '', '_CPPv2', '_CPPv3', '_CPPv4']\n# Ids are used in lookup keys which are used across pickled files,\n# so when _max_id changes, make sure to update the ENV_VERSION.\n\n# ------------------------------------------------------------------------------\n# Id v1 constants\n# ------------------------------------------------------------------------------\n\n_id_fundamental_v1 = {\n 'char': 'c',\n 'signed char': 'c',\n 'unsigned char': 'C',\n 'int': 'i',\n 'signed int': 'i',\n 'unsigned int': 'U',\n 'long': 'l',\n 'signed long': 'l',\n 'unsigned long': 'L',\n 'bool': 'b'\n}\n_id_shorthands_v1 = {\n 'std::string': 'ss',\n 'std::ostream': 'os',\n 'std::istream': 'is',\n 'std::iostream': 'ios',\n 'std::vector': 'v',\n 'std::map': 'm'\n}\n_id_operator_v1 = {\n 'new': 'new-operator',\n 'new[]': 'new-array-operator',\n 'delete': 'delete-operator',\n 'delete[]': 'delete-array-operator',\n # the arguments will make the difference between unary and binary\n # '+(unary)' : 'ps',\n # '-(unary)' : 'ng',\n # '&(unary)' : 'ad',\n # '*(unary)' : 'de',\n '~': 'inv-operator',\n '+': 'add-operator',\n '-': 'sub-operator',\n '*': 'mul-operator',\n '/': 'div-operator',\n '%': 'mod-operator',\n '&': 'and-operator',\n '|': 'or-operator',\n '^': 'xor-operator',\n '=': 'assign-operator',\n '+=': 'add-assign-operator',\n '-=': 'sub-assign-operator',\n '*=': 'mul-assign-operator',\n '/=': 'div-assign-operator',\n '%=': 'mod-assign-operator',\n '&=': 'and-assign-operator',\n '|=': 'or-assign-operator',\n '^=': 'xor-assign-operator',\n '<<': 'lshift-operator',\n '>>': 'rshift-operator',\n '<<=': 'lshift-assign-operator',\n '>>=': 'rshift-assign-operator',\n '==': 'eq-operator',\n '!=': 'neq-operator',\n '<': 'lt-operator',\n '>': 'gt-operator',\n '<=': 'lte-operator',\n '>=': 'gte-operator',\n '!': 'not-operator',\n '&&': 'sand-operator',\n '||': 'sor-operator',\n '++': 'inc-operator',\n '--': 'dec-operator',\n ',': 'comma-operator',\n '->*': 'pointer-by-pointer-operator',\n '->': 'pointer-operator',\n '()': 'call-operator',\n '[]': 'subscript-operator'\n}\n\n# ------------------------------------------------------------------------------\n# Id v > 1 constants\n# ------------------------------------------------------------------------------\n\n_id_fundamental_v2 = {\n # not all of these are actually parsed as fundamental types, TODO: do that\n 'void': 'v',\n 'bool': 'b',\n 'char': 'c',\n 'signed char': 'a',\n 'unsigned char': 'h',\n 'wchar_t': 'w',\n 'char32_t': 'Di',\n 'char16_t': 'Ds',\n 'short': 's',\n 'short int': 's',\n 'signed short': 's',\n 'signed short int': 's',\n 'unsigned short': 't',\n 'unsigned short int': 't',\n 'int': 'i',\n 'signed': 'i',\n 'signed int': 'i',\n 'unsigned': 'j',\n 'unsigned int': 'j',\n 'long': 'l',\n 'long int': 'l',\n 'signed long': 'l',\n 'signed long int': 'l',\n 'unsigned long': 'm',\n 'unsigned long int': 'm',\n 'long long': 'x',\n 'long long int': 'x',\n 'signed long long': 'x',\n 'signed long long int': 'x',\n 'unsigned long long': 'y',\n 'unsigned long long int': 'y',\n 'float': 'f',\n 'double': 'd',\n 'long double': 'e',\n 'auto': 'Da',\n 'decltype(auto)': 'Dc',\n 'std::nullptr_t': 'Dn'\n}\n_id_operator_v2 = {\n 'new': 'nw',\n 'new[]': 'na',\n 'delete': 'dl',\n 'delete[]': 'da',\n # the arguments will make the difference between unary and binary\n # in operator definitions\n # '+(unary)' : 'ps',\n # '-(unary)' : 'ng',\n # '&(unary)' : 'ad',\n # '*(unary)' : 'de',\n '~': 'co', 'compl': 'co',\n '+': 'pl',\n '-': 'mi',\n '*': 'ml',\n '/': 'dv',\n '%': 'rm',\n '&': 'an', 'bitand': 'an',\n '|': 'or', 'bitor': 'or',\n '^': 'eo', 'xor': 'eo',\n '=': 'aS',\n '+=': 'pL',\n '-=': 'mI',\n '*=': 'mL',\n '/=': 'dV',\n '%=': 'rM',\n '&=': 'aN', 'and_eq': 'aN',\n '|=': 'oR', 'or_eq': 'oR',\n '^=': 'eO', 'xor_eq': 'eO',\n '<<': 'ls',\n '>>': 'rs',\n '<<=': 'lS',\n '>>=': 'rS',\n '==': 'eq',\n '!=': 'ne', 'not_eq': 'ne',\n '<': 'lt',\n '>': 'gt',\n '<=': 'le',\n '>=': 'ge',\n '!': 'nt', 'not': 'nt',\n '&&': 'aa', 'and': 'aa',\n '||': 'oo', 'or': 'oo',\n '++': 'pp',\n '--': 'mm',\n ',': 'cm',\n '->*': 'pm',\n '->': 'pt',\n '()': 'cl',\n '[]': 'ix',\n '.*': 'ds' # this one is not overloadable, but we need it for expressions\n}\n_id_operator_unary_v2 = {\n '++': 'pp_',\n '--': 'mm_',\n '*': 'de',\n '&': 'ad',\n '+': 'ps',\n '-': 'ng',\n '!': 'nt', 'not': 'nt',\n '~': 'co', 'compl': 'co'\n}\n_id_char_from_prefix = {\n None: 'c', 'u8': 'c',\n 'u': 'Ds', 'U': 'Di', 'L': 'w'\n} # type: Dict[Any, str]\n# these are ordered by preceedence\n_expression_bin_ops = [\n ['||', 'or'],\n ['&&', 'and'],\n ['|', 'bitor'],\n ['^', 'xor'],\n ['&', 'bitand'],\n ['==', '!=', 'not_eq'],\n ['<=', '>=', '<', '>'],\n ['<<', '>>'],\n ['+', '-'],\n ['*', '/', '%'],\n ['.*', '->*']\n]\n_expression_unary_ops = [\"++\", \"--\", \"*\", \"&\", \"+\", \"-\", \"!\", \"not\", \"~\", \"compl\"]\n_expression_assignment_ops = [\"=\", \"*=\", \"/=\", \"%=\", \"+=\", \"-=\",\n \">>=\", \"<<=\", \"&=\", \"and_eq\", \"^=\", \"|=\", \"xor_eq\", \"or_eq\"]\n_id_explicit_cast = {\n 'dynamic_cast': 'dc',\n 'static_cast': 'sc',\n 'const_cast': 'cc',\n 'reinterpret_cast': 'rc'\n}\n\n\nclass _DuplicateSymbolError(Exception):\n def __init__(self, symbol: \"Symbol\", declaration: \"ASTDeclaration\") -> None:\n assert symbol\n assert declaration\n self.symbol = symbol\n self.declaration = declaration\n\n def __str__(self) -> str:\n return \"Internal C++ duplicate symbol error:\\n%s\" % self.symbol.dump(0)\n\n\nclass ASTBase(ASTBaseBase):\n pass\n\n\n# Names\n################################################################################\n\nclass ASTIdentifier(ASTBase):\n def __init__(self, identifier: str) -> None:\n assert identifier is not None\n assert len(identifier) != 0\n self.identifier = identifier\n\n def is_anon(self) -> bool:\n return self.identifier[0] == '@'\n\n def get_id(self, version: int) -> str:\n if self.is_anon() and version < 3:\n raise NoOldIdError()\n if version == 1:\n if self.identifier == 'size_t':\n return 's'\n else:\n return self.identifier\n if self.identifier == \"std\":\n return 'St'\n elif self.identifier[0] == \"~\":\n # a destructor, just use an arbitrary version of dtors\n return 'D0'\n else:\n if self.is_anon():\n return 'Ut%d_%s' % (len(self.identifier) - 1, self.identifier[1:])\n else:\n return str(len(self.identifier)) + self.identifier\n\n # and this is where we finally make a difference between __str__ and the display string\n\n def __str__(self) -> str:\n return self.identifier\n\n def get_display_string(self) -> str:\n return \"[anonymous]\" if self.is_anon() else self.identifier\n\n def describe_signature(self, signode: TextElement, mode: str, env: \"BuildEnvironment\",\n prefix: str, templateArgs: str, symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if mode == 'markType':\n targetText = prefix + self.identifier + templateArgs\n pnode = addnodes.pending_xref('', refdomain='cpp',\n reftype='identifier',\n reftarget=targetText, modname=None,\n classname=None)\n key = symbol.get_lookup_key()\n pnode['cpp:parent_key'] = key\n if self.is_anon():\n pnode += nodes.strong(text=\"[anonymous]\")\n else:\n pnode += nodes.Text(self.identifier)\n signode += pnode\n elif mode == 'lastIsName':\n if self.is_anon():\n signode += nodes.strong(text=\"[anonymous]\")\n else:\n signode += addnodes.desc_name(self.identifier, self.identifier)\n elif mode == 'noneIsName':\n if self.is_anon():\n signode += nodes.strong(text=\"[anonymous]\")\n else:\n signode += nodes.Text(self.identifier)\n else:\n raise Exception('Unknown description mode: %s' % mode)\n\n\nclass ASTNestedNameElement(ASTBase):\n def __init__(self, identOrOp: Union[ASTIdentifier, \"ASTOperator\"],\n templateArgs: \"ASTTemplateArgs\") -> None:\n self.identOrOp = identOrOp\n self.templateArgs = templateArgs\n\n def is_operator(self) -> bool:\n return False\n\n def get_id(self, version: int) -> str:\n res = self.identOrOp.get_id(version)\n if self.templateArgs:\n res += self.templateArgs.get_id(version)\n return res\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = transform(self.identOrOp)\n if self.templateArgs:\n res += transform(self.templateArgs)\n return res\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", prefix: str, symbol: \"Symbol\") -> None:\n tArgs = str(self.templateArgs) if self.templateArgs is not None else ''\n self.identOrOp.describe_signature(signode, mode, env, prefix, tArgs, symbol)\n if self.templateArgs is not None:\n self.templateArgs.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTNestedName(ASTBase):\n def __init__(self, names: List[ASTNestedNameElement],\n templates: List[bool], rooted: bool) -> None:\n assert len(names) > 0\n self.names = names\n self.templates = templates\n assert len(self.names) == len(self.templates)\n self.rooted = rooted\n\n @property\n def name(self) -> \"ASTNestedName\":\n return self\n\n def num_templates(self) -> int:\n count = 0\n for n in self.names:\n if n.is_operator():\n continue\n if n.templateArgs:\n count += 1\n return count\n\n def get_id(self, version: int, modifiers: str = '') -> str:\n if version == 1:\n tt = str(self)\n if tt in _id_shorthands_v1:\n return _id_shorthands_v1[tt]\n else:\n return '::'.join(n.get_id(version) for n in self.names)\n\n res = []\n if len(self.names) > 1 or len(modifiers) > 0:\n res.append('N')\n res.append(modifiers)\n for n in self.names:\n res.append(n.get_id(version))\n if len(self.names) > 1 or len(modifiers) > 0:\n res.append('E')\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.rooted:\n res.append('')\n for i in range(len(self.names)):\n n = self.names[i]\n t = self.templates[i]\n if t:\n res.append(\"template \" + transform(n))\n else:\n res.append(transform(n))\n return '::'.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n # just print the name part, with template args, not template params\n if mode == 'noneIsName':\n signode += nodes.Text(str(self))\n elif mode == 'param':\n name = str(self)\n signode += nodes.emphasis(name, name)\n elif mode == 'markType' or mode == 'lastIsName' or mode == 'markName':\n # Each element should be a pending xref targeting the complete\n # prefix. however, only the identifier part should be a link, such\n # that template args can be a link as well.\n # For 'lastIsName' we should also prepend template parameter lists.\n templateParams = [] # type: List[Any]\n if mode == 'lastIsName':\n assert symbol is not None\n if symbol.declaration.templatePrefix is not None:\n templateParams = symbol.declaration.templatePrefix.templates\n iTemplateParams = 0\n templateParamsPrefix = ''\n prefix = ''\n first = True\n names = self.names[:-1] if mode == 'lastIsName' else self.names\n # If lastIsName, then wrap all of the prefix in a desc_addname,\n # else append directly to signode.\n # NOTE: Breathe relies on the prefix being in the desc_addname node,\n # so it can remove it in inner declarations.\n dest = signode\n if mode == 'lastIsName':\n dest = addnodes.desc_addname()\n for i in range(len(names)):\n nne = names[i]\n template = self.templates[i]\n if not first:\n dest += nodes.Text('::')\n prefix += '::'\n if template:\n dest += nodes.Text(\"template \")\n first = False\n txt_nne = str(nne)\n if txt_nne != '':\n if nne.templateArgs and iTemplateParams < len(templateParams):\n templateParamsPrefix += str(templateParams[iTemplateParams])\n iTemplateParams += 1\n nne.describe_signature(dest, 'markType',\n env, templateParamsPrefix + prefix, symbol)\n prefix += txt_nne\n if mode == 'lastIsName':\n if len(self.names) > 1:\n dest += addnodes.desc_addname('::', '::')\n signode += dest\n if self.templates[-1]:\n signode += nodes.Text(\"template \")\n self.names[-1].describe_signature(signode, mode, env, '', symbol)\n else:\n raise Exception('Unknown description mode: %s' % mode)\n\n\n################################################################################\n# Expressions\n################################################################################\n\nclass ASTExpression(ASTBase):\n def get_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n raise NotImplementedError(repr(self))\n\n\n# Primary expressions\n################################################################################\n\nclass ASTLiteral(ASTExpression):\n pass\n\n\nclass ASTPointerLiteral(ASTLiteral):\n def _stringify(self, transform: StringifyTransform) -> str:\n return 'nullptr'\n\n def get_id(self, version: int) -> str:\n return 'LDnE'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('nullptr'))\n\n\nclass ASTBooleanLiteral(ASTLiteral):\n def __init__(self, value: bool) -> None:\n self.value = value\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.value:\n return 'true'\n else:\n return 'false'\n\n def get_id(self, version: int) -> str:\n if self.value:\n return 'L1E'\n else:\n return 'L0E'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text(str(self)))\n\n\nclass ASTNumberLiteral(ASTLiteral):\n def __init__(self, data: str) -> None:\n self.data = data\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return self.data\n\n def get_id(self, version: int) -> str:\n return \"L%sE\" % self.data\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n txt = str(self)\n signode.append(nodes.Text(txt, txt))\n\n\nclass ASTStringLiteral(ASTLiteral):\n def __init__(self, data: str) -> None:\n self.data = data\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return self.data\n\n def get_id(self, version: int) -> str:\n # note: the length is not really correct with escaping\n return \"LA%d_KcE\" % (len(self.data) - 2)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n txt = str(self)\n signode.append(nodes.Text(txt, txt))\n\n\nclass ASTCharLiteral(ASTLiteral):\n def __init__(self, prefix: str, data: str) -> None:\n self.prefix = prefix # may be None when no prefix\n self.data = data\n assert prefix in _id_char_from_prefix\n self.type = _id_char_from_prefix[prefix]\n decoded = data.encode().decode('unicode-escape')\n if len(decoded) == 1:\n self.value = ord(decoded)\n else:\n raise UnsupportedMultiCharacterCharLiteral(decoded)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.prefix is None:\n return \"'\" + self.data + \"'\"\n else:\n return self.prefix + \"'\" + self.data + \"'\"\n\n def get_id(self, version: int) -> str:\n return self.type + str(self.value)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n txt = str(self)\n signode.append(nodes.Text(txt, txt))\n\n\nclass ASTThisLiteral(ASTExpression):\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"this\"\n\n def get_id(self, version: int) -> str:\n return \"fpT\"\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text(\"this\"))\n\n\nclass ASTFoldExpr(ASTExpression):\n def __init__(self, leftExpr: ASTExpression,\n op: str, rightExpr: ASTExpression) -> None:\n assert leftExpr is not None or rightExpr is not None\n self.leftExpr = leftExpr\n self.op = op\n self.rightExpr = rightExpr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ['(']\n if self.leftExpr:\n res.append(transform(self.leftExpr))\n res.append(' ')\n res.append(transform(self.op))\n res.append(' ')\n res.append('...')\n if self.rightExpr:\n res.append(' ')\n res.append(transform(self.op))\n res.append(' ')\n res.append(transform(self.rightExpr))\n res.append(')')\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n assert version >= 3\n if version == 3:\n return str(self)\n # https://github.com/itanium-cxx-abi/cxx-abi/pull/67\n res = []\n if self.leftExpr is None: # (... op expr)\n res.append('fl')\n elif self.rightExpr is None: # (expr op ...)\n res.append('fr')\n else: # (expr op ... op expr)\n # we don't check where the parameter pack is,\n # we just always call this a binary left fold\n res.append('fL')\n res.append(_id_operator_v2[self.op])\n if self.leftExpr:\n res.append(self.leftExpr.get_id(version))\n if self.rightExpr:\n res.append(self.rightExpr.get_id(version))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('('))\n if self.leftExpr:\n self.leftExpr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(' '))\n signode.append(nodes.Text(self.op))\n signode.append(nodes.Text(' '))\n signode.append(nodes.Text('...'))\n if self.rightExpr:\n signode.append(nodes.Text(' '))\n signode.append(nodes.Text(self.op))\n signode.append(nodes.Text(' '))\n self.rightExpr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTParenExpr(ASTExpression):\n def __init__(self, expr: ASTExpression):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return '(' + transform(self.expr) + ')'\n\n def get_id(self, version: int) -> str:\n return self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('(', '('))\n self.expr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')', ')'))\n\n\nclass ASTIdExpression(ASTExpression):\n def __init__(self, name: ASTNestedName):\n # note: this class is basically to cast a nested name as an expression\n self.name = name\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.name)\n\n def get_id(self, version: int) -> str:\n return self.name.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.name.describe_signature(signode, mode, env, symbol)\n\n\n# Postfix expressions\n################################################################################\n\nclass ASTPostfixOp(ASTBase):\n def get_id(self, idPrefix: str, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n raise NotImplementedError(repr(self))\n\n\nclass ASTPostfixArray(ASTPostfixOp):\n def __init__(self, expr: ASTExpression):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return '[' + transform(self.expr) + ']'\n\n def get_id(self, idPrefix: str, version: int) -> str:\n return 'ix' + idPrefix + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('['))\n self.expr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(']'))\n\n\nclass ASTPostfixMember(ASTPostfixOp):\n def __init__(self, name: ASTNestedName):\n self.name = name\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return '.' + transform(self.name)\n\n def get_id(self, idPrefix: str, version: int) -> str:\n return 'dt' + idPrefix + self.name.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('.'))\n self.name.describe_signature(signode, 'noneIsName', env, symbol)\n\n\nclass ASTPostfixMemberOfPointer(ASTPostfixOp):\n def __init__(self, name: ASTNestedName):\n self.name = name\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return '->' + transform(self.name)\n\n def get_id(self, idPrefix: str, version: int) -> str:\n return 'pt' + idPrefix + self.name.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('->'))\n self.name.describe_signature(signode, 'noneIsName', env, symbol)\n\n\nclass ASTPostfixInc(ASTPostfixOp):\n def _stringify(self, transform: StringifyTransform) -> str:\n return '++'\n\n def get_id(self, idPrefix: str, version: int) -> str:\n return 'pp' + idPrefix\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('++'))\n\n\nclass ASTPostfixDec(ASTPostfixOp):\n def _stringify(self, transform: StringifyTransform) -> str:\n return '--'\n\n def get_id(self, idPrefix: str, version: int) -> str:\n return 'mm' + idPrefix\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('--'))\n\n\nclass ASTPostfixCallExpr(ASTPostfixOp):\n def __init__(self, lst: Union[\"ASTParenExprList\", \"ASTBracedInitList\"]) -> None:\n self.lst = lst\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.lst)\n\n def get_id(self, idPrefix: str, version: int) -> str:\n res = ['cl', idPrefix]\n for e in self.lst.exprs:\n res.append(e.get_id(version))\n res.append('E')\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.lst.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTPostfixExpr(ASTExpression):\n def __init__(self, prefix: \"ASTType\", postFixes: List[ASTPostfixOp]):\n self.prefix = prefix\n self.postFixes = postFixes\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = [transform(self.prefix)]\n for p in self.postFixes:\n res.append(transform(p))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n id = self.prefix.get_id(version)\n for p in self.postFixes:\n id = p.get_id(id, version)\n return id\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.prefix.describe_signature(signode, mode, env, symbol)\n for p in self.postFixes:\n p.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTExplicitCast(ASTExpression):\n def __init__(self, cast: str, typ: \"ASTType\", expr: ASTExpression):\n assert cast in _id_explicit_cast\n self.cast = cast\n self.typ = typ\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = [self.cast]\n res.append('<')\n res.append(transform(self.typ))\n res.append('>(')\n res.append(transform(self.expr))\n res.append(')')\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n return (_id_explicit_cast[self.cast] +\n self.typ.get_id(version) +\n self.expr.get_id(version))\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text(self.cast))\n signode.append(nodes.Text('<'))\n self.typ.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text('>'))\n signode.append(nodes.Text('('))\n self.expr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTTypeId(ASTExpression):\n def __init__(self, typeOrExpr: Union[\"ASTType\", ASTExpression], isType: bool):\n self.typeOrExpr = typeOrExpr\n self.isType = isType\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return 'typeid(' + transform(self.typeOrExpr) + ')'\n\n def get_id(self, version: int) -> str:\n prefix = 'ti' if self.isType else 'te'\n return prefix + self.typeOrExpr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('typeid'))\n signode.append(nodes.Text('('))\n self.typeOrExpr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\n# Unary expressions\n################################################################################\n\nclass ASTUnaryOpExpr(ASTExpression):\n def __init__(self, op: str, expr: ASTExpression):\n self.op = op\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.op[0] in 'cn':\n return transform(self.op) + \" \" + transform(self.expr)\n else:\n return transform(self.op) + transform(self.expr)\n\n def get_id(self, version: int) -> str:\n return _id_operator_unary_v2[self.op] + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text(self.op))\n if self.op[0] in 'cn':\n signode.append(nodes.Text(' '))\n self.expr.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTSizeofParamPack(ASTExpression):\n def __init__(self, identifier: ASTIdentifier):\n self.identifier = identifier\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"sizeof...(\" + transform(self.identifier) + \")\"\n\n def get_id(self, version: int) -> str:\n return 'sZ' + self.identifier.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('sizeof...('))\n self.identifier.describe_signature(signode, mode, env,\n symbol=symbol, prefix=\"\", templateArgs=\"\")\n signode.append(nodes.Text(')'))\n\n\nclass ASTSizeofType(ASTExpression):\n def __init__(self, typ: \"ASTType\"):\n self.typ = typ\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"sizeof(\" + transform(self.typ) + \")\"\n\n def get_id(self, version: int) -> str:\n return 'st' + self.typ.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('sizeof('))\n self.typ.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTSizeofExpr(ASTExpression):\n def __init__(self, expr: ASTExpression):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"sizeof \" + transform(self.expr)\n\n def get_id(self, version: int) -> str:\n return 'sz' + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('sizeof '))\n self.expr.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTAlignofExpr(ASTExpression):\n def __init__(self, typ: \"ASTType\"):\n self.typ = typ\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"alignof(\" + transform(self.typ) + \")\"\n\n def get_id(self, version: int) -> str:\n return 'at' + self.typ.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('alignof('))\n self.typ.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTNoexceptExpr(ASTExpression):\n def __init__(self, expr: ASTExpression):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"noexcept(\" + transform(self.expr) + \")\"\n\n def get_id(self, version: int) -> str:\n return 'nx' + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('noexcept('))\n self.expr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTNewExpr(ASTExpression):\n def __init__(self, rooted: bool, isNewTypeId: bool, typ: \"ASTType\",\n initList: Union[\"ASTParenExprList\", \"ASTBracedInitList\"]) -> None:\n self.rooted = rooted\n self.isNewTypeId = isNewTypeId\n self.typ = typ\n self.initList = initList\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.rooted:\n res.append('::')\n res.append('new ')\n # TODO: placement\n if self.isNewTypeId:\n res.append(transform(self.typ))\n else:\n assert False\n if self.initList is not None:\n res.append(transform(self.initList))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n # the array part will be in the type mangling, so na is not used\n res = ['nw']\n # TODO: placement\n res.append('_')\n res.append(self.typ.get_id(version))\n if self.initList is not None:\n res.append(self.initList.get_id(version))\n else:\n res.append('E')\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n if self.rooted:\n signode.append(nodes.Text('::'))\n signode.append(nodes.Text('new '))\n # TODO: placement\n if self.isNewTypeId:\n self.typ.describe_signature(signode, mode, env, symbol)\n else:\n assert False\n if self.initList is not None:\n self.initList.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeleteExpr(ASTExpression):\n def __init__(self, rooted: bool, array: bool, expr: ASTExpression):\n self.rooted = rooted\n self.array = array\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.rooted:\n res.append('::')\n res.append('delete ')\n if self.array:\n res.append('[] ')\n res.append(transform(self.expr))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n if self.array:\n id = \"da\"\n else:\n id = \"dl\"\n return id + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n if self.rooted:\n signode.append(nodes.Text('::'))\n signode.append(nodes.Text('delete '))\n if self.array:\n signode.append(nodes.Text('[] '))\n self.expr.describe_signature(signode, mode, env, symbol)\n\n\n# Other expressions\n################################################################################\n\nclass ASTCastExpr(ASTExpression):\n def __init__(self, typ: \"ASTType\", expr: ASTExpression):\n self.typ = typ\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ['(']\n res.append(transform(self.typ))\n res.append(')')\n res.append(transform(self.expr))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n return 'cv' + self.typ.get_id(version) + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('('))\n self.typ.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n self.expr.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTBinOpExpr(ASTExpression):\n def __init__(self, exprs: List[ASTExpression], ops: List[str]):\n assert len(exprs) > 0\n assert len(exprs) == len(ops) + 1\n self.exprs = exprs\n self.ops = ops\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.exprs[0]))\n for i in range(1, len(self.exprs)):\n res.append(' ')\n res.append(self.ops[i - 1])\n res.append(' ')\n res.append(transform(self.exprs[i]))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n assert version >= 2\n res = []\n for i in range(len(self.ops)):\n res.append(_id_operator_v2[self.ops[i]])\n res.append(self.exprs[i].get_id(version))\n res.append(self.exprs[-1].get_id(version))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.exprs[0].describe_signature(signode, mode, env, symbol)\n for i in range(1, len(self.exprs)):\n signode.append(nodes.Text(' '))\n signode.append(nodes.Text(self.ops[i - 1]))\n signode.append(nodes.Text(' '))\n self.exprs[i].describe_signature(signode, mode, env, symbol)\n\n\nclass ASTBracedInitList(ASTBase):\n def __init__(self, exprs: List[Union[ASTExpression, \"ASTBracedInitList\"]],\n trailingComma: bool) -> None:\n self.exprs = exprs\n self.trailingComma = trailingComma\n\n def get_id(self, version: int) -> str:\n return \"il%sE\" % ''.join(e.get_id(version) for e in self.exprs)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n exprs = [transform(e) for e in self.exprs]\n trailingComma = ',' if self.trailingComma else ''\n return '{%s%s}' % (', '.join(exprs), trailingComma)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode.append(nodes.Text('{'))\n first = True\n for e in self.exprs:\n if not first:\n signode.append(nodes.Text(', '))\n else:\n first = False\n e.describe_signature(signode, mode, env, symbol)\n if self.trailingComma:\n signode.append(nodes.Text(','))\n signode.append(nodes.Text('}'))\n\n\nclass ASTAssignmentExpr(ASTExpression):\n def __init__(self, exprs: List[Union[ASTExpression, ASTBracedInitList]], ops: List[str]):\n assert len(exprs) > 0\n assert len(exprs) == len(ops) + 1\n self.exprs = exprs\n self.ops = ops\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.exprs[0]))\n for i in range(1, len(self.exprs)):\n res.append(' ')\n res.append(self.ops[i - 1])\n res.append(' ')\n res.append(transform(self.exprs[i]))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n res = []\n for i in range(len(self.ops)):\n res.append(_id_operator_v2[self.ops[i]])\n res.append(self.exprs[i].get_id(version))\n res.append(self.exprs[-1].get_id(version))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.exprs[0].describe_signature(signode, mode, env, symbol)\n for i in range(1, len(self.exprs)):\n signode.append(nodes.Text(' '))\n signode.append(nodes.Text(self.ops[i - 1]))\n signode.append(nodes.Text(' '))\n self.exprs[i].describe_signature(signode, mode, env, symbol)\n\n\nclass ASTCommaExpr(ASTExpression):\n def __init__(self, exprs: List[ASTExpression]):\n assert len(exprs) > 0\n self.exprs = exprs\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return ', '.join(transform(e) for e in self.exprs)\n\n def get_id(self, version: int) -> str:\n id_ = _id_operator_v2[',']\n res = []\n for i in range(len(self.exprs) - 1):\n res.append(id_)\n res.append(self.exprs[i].get_id(version))\n res.append(self.exprs[-1].get_id(version))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.exprs[0].describe_signature(signode, mode, env, symbol)\n for i in range(1, len(self.exprs)):\n signode.append(nodes.Text(', '))\n self.exprs[i].describe_signature(signode, mode, env, symbol)\n\n\nclass ASTFallbackExpr(ASTExpression):\n def __init__(self, expr: str):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return self.expr\n\n def get_id(self, version: int) -> str:\n return str(self.expr)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode += nodes.Text(self.expr)\n\n\n################################################################################\n# Types\n################################################################################\n\n# Things for ASTNestedName\n################################################################################\n\nclass ASTOperator(ASTBase):\n def is_anon(self) -> bool:\n return False\n\n def is_operator(self) -> bool:\n return True\n\n def get_id(self, version: int) -> str:\n raise NotImplementedError()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", prefix: str, templateArgs: str,\n symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n identifier = str(self)\n if mode == 'lastIsName':\n signode += addnodes.desc_name(identifier, identifier)\n else:\n signode += addnodes.desc_addname(identifier, identifier)\n\n\nclass ASTOperatorBuildIn(ASTOperator):\n def __init__(self, op: str) -> None:\n self.op = op\n\n def get_id(self, version: int) -> str:\n if version == 1:\n ids = _id_operator_v1\n if self.op not in ids:\n raise NoOldIdError()\n else:\n ids = _id_operator_v2\n if self.op not in ids:\n raise Exception('Internal error: Build-in operator \"%s\" can not '\n 'be mapped to an id.' % self.op)\n return ids[self.op]\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.op in ('new', 'new[]', 'delete', 'delete[]') or self.op[0] in \"abcnox\":\n return 'operator ' + self.op\n else:\n return 'operator' + self.op\n\n\nclass ASTOperatorLiteral(ASTOperator):\n def __init__(self, identifier: ASTIdentifier) -> None:\n self.identifier = identifier\n\n def get_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError()\n else:\n return 'li' + self.identifier.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return 'operator\"\"' + transform(self.identifier)\n\n\nclass ASTOperatorType(ASTOperator):\n def __init__(self, type: \"ASTType\") -> None:\n self.type = type\n\n def get_id(self, version: int) -> str:\n if version == 1:\n return 'castto-%s-operator' % self.type.get_id(version)\n else:\n return 'cv' + self.type.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return ''.join(['operator ', transform(self.type)])\n\n def get_name_no_template(self) -> str:\n return str(self)\n\n\nclass ASTTemplateArgConstant(ASTBase):\n def __init__(self, value: ASTExpression) -> None:\n self.value = value\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.value)\n\n def get_id(self, version: int) -> str:\n if version == 1:\n return str(self).replace(' ', '-')\n if version == 2:\n return 'X' + str(self) + 'E'\n return 'X' + self.value.get_id(version) + 'E'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.value.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTemplateArgs(ASTBase):\n def __init__(self, args: List[Union[\"ASTType\", ASTTemplateArgConstant]],\n packExpansion: bool) -> None:\n assert args is not None\n self.args = args\n self.packExpansion = packExpansion\n\n def get_id(self, version: int) -> str:\n if version == 1:\n res = []\n res.append(':')\n res.append('.'.join(a.get_id(version) for a in self.args))\n res.append(':')\n return ''.join(res)\n\n res = []\n res.append('I')\n if len(self.args) > 0:\n for a in self.args[:-1]:\n res.append(a.get_id(version))\n if self.packExpansion:\n res.append('J')\n res.append(self.args[-1].get_id(version))\n if self.packExpansion:\n res.append('E')\n res.append('E')\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ', '.join(transform(a) for a in self.args)\n if self.packExpansion:\n res += '...'\n return '<' + res + '>'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode += nodes.Text('<')\n first = True\n for a in self.args:\n if not first:\n signode += nodes.Text(', ')\n first = False\n a.describe_signature(signode, 'markType', env, symbol=symbol)\n if self.packExpansion:\n signode += nodes.Text('...')\n signode += nodes.Text('>')\n\n\n# Main part of declarations\n################################################################################\n\nclass ASTTrailingTypeSpec(ASTBase):\n def get_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n raise NotImplementedError(repr(self))\n\n\nclass ASTTrailingTypeSpecFundamental(ASTTrailingTypeSpec):\n def __init__(self, name: str) -> None:\n self.name = name\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return self.name\n\n def get_id(self, version: int) -> str:\n if version == 1:\n res = []\n for a in self.name.split(' '):\n if a in _id_fundamental_v1:\n res.append(_id_fundamental_v1[a])\n else:\n res.append(a)\n return '-'.join(res)\n\n if self.name not in _id_fundamental_v2:\n raise Exception(\n 'Semi-internal error: Fundamental type \"%s\" can not be mapped '\n 'to an id. Is it a true fundamental type? If not so, the '\n 'parser should have rejected it.' % self.name)\n return _id_fundamental_v2[self.name]\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode += nodes.Text(str(self.name))\n\n\nclass ASTTrailingTypeSpecDecltypeAuto(ASTTrailingTypeSpec):\n def _stringify(self, transform: StringifyTransform) -> str:\n return 'decltype(auto)'\n\n def get_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError()\n return 'Dc'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text(str(self)))\n\n\nclass ASTTrailingTypeSpecDecltype(ASTTrailingTypeSpec):\n def __init__(self, expr: ASTExpression):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return 'decltype(' + transform(self.expr) + ')'\n\n def get_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError()\n return 'DT' + self.expr.get_id(version) + \"E\"\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('decltype('))\n self.expr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTTrailingTypeSpecName(ASTTrailingTypeSpec):\n def __init__(self, prefix: str, nestedName: ASTNestedName) -> None:\n self.prefix = prefix\n self.nestedName = nestedName\n\n @property\n def name(self) -> ASTNestedName:\n return self.nestedName\n\n def get_id(self, version: int) -> str:\n return self.nestedName.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.prefix:\n res.append(self.prefix)\n res.append(' ')\n res.append(transform(self.nestedName))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n if self.prefix:\n signode += addnodes.desc_annotation(self.prefix, self.prefix)\n signode += nodes.Text(' ')\n self.nestedName.describe_signature(signode, mode, env, symbol=symbol)\n\n\nclass ASTFunctionParameter(ASTBase):\n def __init__(self, arg: Union[\"ASTTypeWithInit\",\n \"ASTTemplateParamConstrainedTypeWithInit\"],\n ellipsis: bool = False) -> None:\n self.arg = arg\n self.ellipsis = ellipsis\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n # this is not part of the normal name mangling in C++\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=None)\n # else, do the usual\n if self.ellipsis:\n return 'z'\n else:\n return self.arg.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.ellipsis:\n return '...'\n else:\n return transform(self.arg)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if self.ellipsis:\n signode += nodes.Text('...')\n else:\n self.arg.describe_signature(signode, mode, env, symbol=symbol)\n\n\nclass ASTParametersQualifiers(ASTBase):\n def __init__(self, args: List[ASTFunctionParameter],\n volatile: bool, const: bool, refQual: str,\n exceptionSpec: str, override: bool, final: bool, initializer: str) -> None:\n self.args = args\n self.volatile = volatile\n self.const = const\n self.refQual = refQual\n self.exceptionSpec = exceptionSpec\n self.override = override\n self.final = final\n self.initializer = initializer\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.args\n\n def get_modifiers_id(self, version: int) -> str:\n res = []\n if self.volatile:\n res.append('V')\n if self.const:\n if version == 1:\n res.append('C')\n else:\n res.append('K')\n if self.refQual == '&&':\n res.append('O')\n elif self.refQual == '&':\n res.append('R')\n return ''.join(res)\n\n def get_param_id(self, version: int) -> str:\n if version == 1:\n if len(self.args) == 0:\n return ''\n else:\n return '__' + '.'.join(a.get_id(version) for a in self.args)\n if len(self.args) == 0:\n return 'v'\n else:\n return ''.join(a.get_id(version) for a in self.args)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append('(')\n first = True\n for a in self.args:\n if not first:\n res.append(', ')\n first = False\n res.append(str(a))\n res.append(')')\n if self.volatile:\n res.append(' volatile')\n if self.const:\n res.append(' const')\n if self.refQual:\n res.append(' ')\n res.append(self.refQual)\n if self.exceptionSpec:\n res.append(' ')\n res.append(str(self.exceptionSpec))\n if self.final:\n res.append(' final')\n if self.override:\n res.append(' override')\n if self.initializer:\n res.append(' = ')\n res.append(self.initializer)\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n paramlist = addnodes.desc_parameterlist()\n for arg in self.args:\n param = addnodes.desc_parameter('', '', noemph=True)\n if mode == 'lastIsName': # i.e., outer-function params\n arg.describe_signature(param, 'param', env, symbol=symbol)\n else:\n arg.describe_signature(param, 'markType', env, symbol=symbol)\n paramlist += param\n signode += paramlist\n\n def _add_anno(signode: TextElement, text: str) -> None:\n signode += nodes.Text(' ')\n signode += addnodes.desc_annotation(text, text)\n\n def _add_text(signode: TextElement, text: str) -> None:\n signode += nodes.Text(' ' + text)\n\n if self.volatile:\n _add_anno(signode, 'volatile')\n if self.const:\n _add_anno(signode, 'const')\n if self.refQual:\n _add_text(signode, self.refQual)\n if self.exceptionSpec:\n _add_anno(signode, str(self.exceptionSpec))\n if self.final:\n _add_anno(signode, 'final')\n if self.override:\n _add_anno(signode, 'override')\n if self.initializer:\n _add_text(signode, '= ' + str(self.initializer))\n\n\nclass ASTDeclSpecsSimple(ASTBase):\n def __init__(self, storage: str, threadLocal: bool, inline: bool, virtual: bool,\n explicit: bool, constexpr: bool, volatile: bool, const: bool,\n friend: bool, attrs: List[ASTAttribute]) -> None:\n self.storage = storage\n self.threadLocal = threadLocal\n self.inline = inline\n self.virtual = virtual\n self.explicit = explicit\n self.constexpr = constexpr\n self.volatile = volatile\n self.const = const\n self.friend = friend\n self.attrs = attrs\n\n def mergeWith(self, other: \"ASTDeclSpecsSimple\") -> \"ASTDeclSpecsSimple\":\n if not other:\n return self\n return ASTDeclSpecsSimple(self.storage or other.storage,\n self.threadLocal or other.threadLocal,\n self.inline or other.inline,\n self.virtual or other.virtual,\n self.explicit or other.explicit,\n self.constexpr or other.constexpr,\n self.volatile or other.volatile,\n self.const or other.const,\n self.friend or other.friend,\n self.attrs + other.attrs)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = [] # type: List[str]\n res.extend(transform(attr) for attr in self.attrs)\n if self.storage:\n res.append(self.storage)\n if self.threadLocal:\n res.append('thread_local')\n if self.inline:\n res.append('inline')\n if self.friend:\n res.append('friend')\n if self.virtual:\n res.append('virtual')\n if self.explicit:\n res.append('explicit')\n if self.constexpr:\n res.append('constexpr')\n if self.volatile:\n res.append('volatile')\n if self.const:\n res.append('const')\n return ' '.join(res)\n\n def describe_signature(self, signode: TextElement) -> None:\n addSpace = False\n for attr in self.attrs:\n if addSpace:\n signode += nodes.Text(' ')\n addSpace = True\n attr.describe_signature(signode)\n\n def _add(signode: TextElement, text: str) -> bool:\n if addSpace:\n signode += nodes.Text(' ')\n signode += addnodes.desc_annotation(text, text)\n return True\n\n if self.storage:\n addSpace = _add(signode, self.storage)\n if self.threadLocal:\n addSpace = _add(signode, 'thread_local')\n if self.inline:\n addSpace = _add(signode, 'inline')\n if self.friend:\n addSpace = _add(signode, 'friend')\n if self.virtual:\n addSpace = _add(signode, 'virtual')\n if self.explicit:\n addSpace = _add(signode, 'explicit')\n if self.constexpr:\n addSpace = _add(signode, 'constexpr')\n if self.volatile:\n addSpace = _add(signode, 'volatile')\n if self.const:\n addSpace = _add(signode, 'const')\n\n\nclass ASTDeclSpecs(ASTBase):\n def __init__(self, outer: str,\n leftSpecs: ASTDeclSpecsSimple, rightSpecs: ASTDeclSpecsSimple,\n trailing: ASTTrailingTypeSpec) -> None:\n # leftSpecs and rightSpecs are used for output\n # allSpecs are used for id generation\n self.outer = outer\n self.leftSpecs = leftSpecs\n self.rightSpecs = rightSpecs\n self.allSpecs = self.leftSpecs.mergeWith(self.rightSpecs)\n self.trailingTypeSpec = trailing\n\n def get_id(self, version: int) -> str:\n if version == 1:\n res = []\n res.append(self.trailingTypeSpec.get_id(version))\n if self.allSpecs.volatile:\n res.append('V')\n if self.allSpecs.const:\n res.append('C')\n return ''.join(res)\n res = []\n if self.allSpecs.volatile:\n res.append('V')\n if self.allSpecs.const:\n res.append('K')\n if self.trailingTypeSpec is not None:\n res.append(self.trailingTypeSpec.get_id(version))\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = [] # type: List[str]\n l = transform(self.leftSpecs)\n if len(l) > 0:\n res.append(l)\n if self.trailingTypeSpec:\n if len(res) > 0:\n res.append(\" \")\n res.append(transform(self.trailingTypeSpec))\n r = str(self.rightSpecs)\n if len(r) > 0:\n if len(res) > 0:\n res.append(\" \")\n res.append(r)\n return \"\".join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n numChildren = len(signode)\n self.leftSpecs.describe_signature(signode)\n addSpace = len(signode) != numChildren\n\n if self.trailingTypeSpec:\n if addSpace:\n signode += nodes.Text(' ')\n numChildren = len(signode)\n self.trailingTypeSpec.describe_signature(signode, mode, env,\n symbol=symbol)\n addSpace = len(signode) != numChildren\n\n if len(str(self.rightSpecs)) > 0:\n if addSpace:\n signode += nodes.Text(' ')\n self.rightSpecs.describe_signature(signode)\n\n\n# Declarator\n################################################################################\n\nclass ASTArray(ASTBase):\n def __init__(self, size: ASTExpression):\n self.size = size\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.size:\n return '[' + transform(self.size) + ']'\n else:\n return '[]'\n\n def get_id(self, version: int) -> str:\n if version == 1:\n return 'A'\n if version == 2:\n if self.size:\n return 'A' + str(self.size) + '_'\n else:\n return 'A_'\n if self.size:\n return 'A' + self.size.get_id(version) + '_'\n else:\n return 'A_'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode.append(nodes.Text(\"[\"))\n if self.size:\n self.size.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(\"]\"))\n\n\nclass ASTDeclarator(ASTBase):\n @property\n def name(self) -> ASTNestedName:\n raise NotImplementedError(repr(self))\n\n @property\n def isPack(self) -> bool:\n raise NotImplementedError(repr(self))\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n raise NotImplementedError(repr(self))\n\n def require_space_after_declSpecs(self) -> bool:\n raise NotImplementedError(repr(self))\n\n def get_modifiers_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def get_param_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def get_ptr_suffix_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n raise NotImplementedError(repr(self))\n\n def is_function_type(self) -> bool:\n raise NotImplementedError(repr(self))\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n raise NotImplementedError(repr(self))\n\n\nclass ASTDeclaratorNameParamQual(ASTDeclarator):\n def __init__(self, declId: ASTNestedName,\n arrayOps: List[ASTArray],\n paramQual: ASTParametersQualifiers) -> None:\n self.declId = declId\n self.arrayOps = arrayOps\n self.paramQual = paramQual\n\n @property\n def name(self) -> ASTNestedName:\n return self.declId\n\n @property\n def isPack(self) -> bool:\n return False\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.paramQual.function_params\n\n # only the modifiers for a function, e.g.,\n def get_modifiers_id(self, version: int) -> str:\n # cv-qualifiers\n if self.paramQual:\n return self.paramQual.get_modifiers_id(version)\n raise Exception(\"This should only be called on a function: %s\" % self)\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n if self.paramQual:\n return self.paramQual.get_param_id(version)\n else:\n return ''\n\n def get_ptr_suffix_id(self, version: int) -> str: # only the array specifiers\n return ''.join(a.get_id(version) for a in self.arrayOps)\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n assert version >= 2\n res = []\n # TOOD: can we actually have both array ops and paramQual?\n res.append(self.get_ptr_suffix_id(version))\n if self.paramQual:\n res.append(self.get_modifiers_id(version))\n res.append('F')\n res.append(returnTypeId)\n res.append(self.get_param_id(version))\n res.append('E')\n else:\n res.append(returnTypeId)\n return ''.join(res)\n\n # ------------------------------------------------------------------------\n\n def require_space_after_declSpecs(self) -> bool:\n return self.declId is not None\n\n def is_function_type(self) -> bool:\n return self.paramQual is not None\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.declId:\n res.append(transform(self.declId))\n for op in self.arrayOps:\n res.append(transform(op))\n if self.paramQual:\n res.append(transform(self.paramQual))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if self.declId:\n self.declId.describe_signature(signode, mode, env, symbol)\n for op in self.arrayOps:\n op.describe_signature(signode, mode, env, symbol)\n if self.paramQual:\n self.paramQual.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorNameBitField(ASTDeclarator):\n def __init__(self, declId: ASTNestedName, size: ASTExpression):\n self.declId = declId\n self.size = size\n\n @property\n def name(self) -> ASTNestedName:\n return self.declId\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n return ''\n\n def get_ptr_suffix_id(self, version: int) -> str: # only the array specifiers\n return ''\n\n # ------------------------------------------------------------------------\n\n def require_space_after_declSpecs(self) -> bool:\n return self.declId is not None\n\n def is_function_type(self) -> bool:\n return False\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.declId:\n res.append(transform(self.declId))\n res.append(\" : \")\n res.append(transform(self.size))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if self.declId:\n self.declId.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(' : ', ' : '))\n self.size.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorPtr(ASTDeclarator):\n def __init__(self, next: ASTDeclarator, volatile: bool, const: bool,\n attrs: List[ASTAttribute]) -> None:\n assert next\n self.next = next\n self.volatile = volatile\n self.const = const\n self.attrs = attrs\n\n @property\n def name(self) -> ASTNestedName:\n return self.next.name\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.next.function_params\n\n def require_space_after_declSpecs(self) -> bool:\n return self.next.require_space_after_declSpecs()\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ['*']\n for a in self.attrs:\n res.append(transform(a))\n if len(self.attrs) > 0 and (self.volatile or self.const):\n res.append(' ')\n if self.volatile:\n res.append('volatile')\n if self.const:\n if self.volatile:\n res.append(' ')\n res.append('const')\n if self.const or self.volatile or len(self.attrs) > 0:\n if self.next.require_space_after_declSpecs():\n res.append(' ')\n res.append(transform(self.next))\n return ''.join(res)\n\n def get_modifiers_id(self, version: int) -> str:\n return self.next.get_modifiers_id(version)\n\n def get_param_id(self, version: int) -> str:\n return self.next.get_param_id(version)\n\n def get_ptr_suffix_id(self, version: int) -> str:\n if version == 1:\n res = ['P']\n if self.volatile:\n res.append('V')\n if self.const:\n res.append('C')\n res.append(self.next.get_ptr_suffix_id(version))\n return ''.join(res)\n\n res = [self.next.get_ptr_suffix_id(version)]\n res.append('P')\n if self.volatile:\n res.append('V')\n if self.const:\n res.append('C')\n return ''.join(res)\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n # ReturnType *next, so we are part of the return type of 'next\n res = ['P']\n if self.volatile:\n res.append('V')\n if self.const:\n res.append('C')\n res.append(returnTypeId)\n return self.next.get_type_id(version, returnTypeId=''.join(res))\n\n def is_function_type(self) -> bool:\n return self.next.is_function_type()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode += nodes.Text(\"*\")\n for a in self.attrs:\n a.describe_signature(signode)\n if len(self.attrs) > 0 and (self.volatile or self.const):\n signode += nodes.Text(' ')\n\n def _add_anno(signode: TextElement, text: str) -> None:\n signode += addnodes.desc_annotation(text, text)\n if self.volatile:\n _add_anno(signode, 'volatile')\n if self.const:\n if self.volatile:\n signode += nodes.Text(' ')\n _add_anno(signode, 'const')\n if self.const or self.volatile or len(self.attrs) > 0:\n if self.next.require_space_after_declSpecs():\n signode += nodes.Text(' ')\n self.next.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorRef(ASTDeclarator):\n def __init__(self, next: ASTDeclarator, attrs: List[ASTAttribute]) -> None:\n assert next\n self.next = next\n self.attrs = attrs\n\n @property\n def name(self) -> ASTNestedName:\n return self.next.name\n\n @property\n def isPack(self) -> bool:\n return True\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.next.function_params\n\n def require_space_after_declSpecs(self) -> bool:\n return self.next.require_space_after_declSpecs()\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ['&']\n for a in self.attrs:\n res.append(transform(a))\n if len(self.attrs) > 0 and self.next.require_space_after_declSpecs():\n res.append(' ')\n res.append(transform(self.next))\n return ''.join(res)\n\n def get_modifiers_id(self, version: int) -> str:\n return self.next.get_modifiers_id(version)\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n return self.next.get_param_id(version)\n\n def get_ptr_suffix_id(self, version: int) -> str:\n if version == 1:\n return 'R' + self.next.get_ptr_suffix_id(version)\n else:\n return self.next.get_ptr_suffix_id(version) + 'R'\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n assert version >= 2\n # ReturnType &next, so we are part of the return type of 'next\n return self.next.get_type_id(version, returnTypeId='R' + returnTypeId)\n\n def is_function_type(self) -> bool:\n return self.next.is_function_type()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode += nodes.Text(\"&\")\n for a in self.attrs:\n a.describe_signature(signode)\n if len(self.attrs) > 0 and self.next.require_space_after_declSpecs():\n signode += nodes.Text(' ')\n self.next.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorParamPack(ASTDeclarator):\n def __init__(self, next: ASTDeclarator) -> None:\n assert next\n self.next = next\n\n @property\n def name(self) -> ASTNestedName:\n return self.next.name\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.next.function_params\n\n def require_space_after_declSpecs(self) -> bool:\n return False\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = transform(self.next)\n if self.next.name:\n res = ' ' + res\n return '...' + res\n\n def get_modifiers_id(self, version: int) -> str:\n return self.next.get_modifiers_id(version)\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n return self.next.get_param_id(version)\n\n def get_ptr_suffix_id(self, version: int) -> str:\n if version == 1:\n return 'Dp' + self.next.get_ptr_suffix_id(version)\n else:\n return self.next.get_ptr_suffix_id(version) + 'Dp'\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n assert version >= 2\n # ReturnType... next, so we are part of the return type of 'next\n return self.next.get_type_id(version, returnTypeId='Dp' + returnTypeId)\n\n def is_function_type(self) -> bool:\n return self.next.is_function_type()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode += nodes.Text(\"...\")\n if self.next.name:\n signode += nodes.Text(' ')\n self.next.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorMemPtr(ASTDeclarator):\n def __init__(self, className: ASTNestedName,\n const: bool, volatile: bool, next: ASTDeclarator) -> None:\n assert className\n assert next\n self.className = className\n self.const = const\n self.volatile = volatile\n self.next = next\n\n @property\n def name(self) -> ASTNestedName:\n return self.next.name\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.next.function_params\n\n def require_space_after_declSpecs(self) -> bool:\n return True\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.className))\n res.append('::*')\n if self.volatile:\n res.append('volatile')\n if self.const:\n if self.volatile:\n res.append(' ')\n res.append('const')\n if self.next.require_space_after_declSpecs():\n res.append(' ')\n res.append(transform(self.next))\n return ''.join(res)\n\n def get_modifiers_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError()\n else:\n return self.next.get_modifiers_id(version)\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n if version == 1:\n raise NoOldIdError()\n else:\n return self.next.get_param_id(version)\n\n def get_ptr_suffix_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError()\n else:\n raise NotImplementedError()\n return self.next.get_ptr_suffix_id(version) + 'Dp'\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n assert version >= 2\n # ReturnType name::* next, so we are part of the return type of next\n nextReturnTypeId = ''\n if self.volatile:\n nextReturnTypeId += 'V'\n if self.const:\n nextReturnTypeId += 'K'\n nextReturnTypeId += 'M'\n nextReturnTypeId += self.className.get_id(version)\n nextReturnTypeId += returnTypeId\n return self.next.get_type_id(version, nextReturnTypeId)\n\n def is_function_type(self) -> bool:\n return self.next.is_function_type()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.className.describe_signature(signode, mode, env, symbol)\n signode += nodes.Text('::*')\n\n def _add_anno(signode: TextElement, text: str) -> None:\n signode += addnodes.desc_annotation(text, text)\n if self.volatile:\n _add_anno(signode, 'volatile')\n if self.const:\n if self.volatile:\n signode += nodes.Text(' ')\n _add_anno(signode, 'const')\n if self.next.require_space_after_declSpecs():\n signode += nodes.Text(' ')\n self.next.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorParen(ASTDeclarator):\n def __init__(self, inner: ASTDeclarator, next: ASTDeclarator) -> None:\n assert inner\n assert next\n self.inner = inner\n self.next = next\n # TODO: we assume the name, params, and qualifiers are in inner\n\n @property\n def name(self) -> ASTNestedName:\n return self.inner.name\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.inner.function_params\n\n def require_space_after_declSpecs(self) -> bool:\n return True\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ['(']\n res.append(transform(self.inner))\n res.append(')')\n res.append(transform(self.next))\n return ''.join(res)\n\n def get_modifiers_id(self, version: int) -> str:\n return self.inner.get_modifiers_id(version)\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n return self.inner.get_param_id(version)\n\n def get_ptr_suffix_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError() # TODO: was this implemented before?\n return self.next.get_ptr_suffix_id(version) + \\\n self.inner.get_ptr_suffix_id(version)\n else:\n return self.inner.get_ptr_suffix_id(version) + \\\n self.next.get_ptr_suffix_id(version)\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n assert version >= 2\n # ReturnType (inner)next, so 'inner' returns everything outside\n nextId = self.next.get_type_id(version, returnTypeId)\n return self.inner.get_type_id(version, returnTypeId=nextId)\n\n def is_function_type(self) -> bool:\n return self.inner.is_function_type()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode += nodes.Text('(')\n self.inner.describe_signature(signode, mode, env, symbol)\n signode += nodes.Text(')')\n self.next.describe_signature(signode, \"noneIsName\", env, symbol)\n\n\n# Type and initializer stuff\n##############################################################################################\n\nclass ASTPackExpansionExpr(ASTExpression):\n def __init__(self, expr: Union[ASTExpression, ASTBracedInitList]):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.expr) + '...'\n\n def get_id(self, version: int) -> str:\n id = self.expr.get_id(version)\n return 'sp' + id\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.expr.describe_signature(signode, mode, env, symbol)\n signode += nodes.Text('...')\n\n\nclass ASTParenExprList(ASTBase):\n def __init__(self, exprs: List[Union[ASTExpression, ASTBracedInitList]]) -> None:\n self.exprs = exprs\n\n def get_id(self, version: int) -> str:\n return \"pi%sE\" % ''.join(e.get_id(version) for e in self.exprs)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n exprs = [transform(e) for e in self.exprs]\n return '(%s)' % ', '.join(exprs)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode.append(nodes.Text('('))\n first = True\n for e in self.exprs:\n if not first:\n signode.append(nodes.Text(', '))\n else:\n first = False\n e.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTInitializer(ASTBase):\n def __init__(self, value: Union[ASTExpression, ASTBracedInitList],\n hasAssign: bool = True) -> None:\n self.value = value\n self.hasAssign = hasAssign\n\n def _stringify(self, transform: StringifyTransform) -> str:\n val = transform(self.value)\n if self.hasAssign:\n return ' = ' + val\n else:\n return val\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if self.hasAssign:\n signode.append(nodes.Text(' = '))\n self.value.describe_signature(signode, 'markType', env, symbol)\n\n\nclass ASTType(ASTBase):\n def __init__(self, declSpecs: ASTDeclSpecs, decl: ASTDeclarator) -> None:\n assert declSpecs\n assert decl\n self.declSpecs = declSpecs\n self.decl = decl\n\n @property\n def name(self) -> ASTNestedName:\n return self.decl.name\n\n @property\n def isPack(self) -> bool:\n return self.decl.isPack\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.decl.function_params\n\n def get_id(self, version: int, objectType: str = None,\n symbol: \"Symbol\" = None) -> str:\n if version == 1:\n res = []\n if objectType: # needs the name\n if objectType == 'function': # also modifiers\n res.append(symbol.get_full_nested_name().get_id(version))\n res.append(self.decl.get_param_id(version))\n res.append(self.decl.get_modifiers_id(version))\n if (self.declSpecs.leftSpecs.constexpr or\n (self.declSpecs.rightSpecs and\n self.declSpecs.rightSpecs.constexpr)):\n res.append('CE')\n elif objectType == 'type': # just the name\n res.append(symbol.get_full_nested_name().get_id(version))\n else:\n print(objectType)\n assert False\n else: # only type encoding\n if self.decl.is_function_type():\n raise NoOldIdError()\n res.append(self.declSpecs.get_id(version))\n res.append(self.decl.get_ptr_suffix_id(version))\n res.append(self.decl.get_param_id(version))\n return ''.join(res)\n # other versions\n res = []\n if objectType: # needs the name\n if objectType == 'function': # also modifiers\n modifiers = self.decl.get_modifiers_id(version)\n res.append(symbol.get_full_nested_name().get_id(version, modifiers))\n if version >= 4:\n # with templates we need to mangle the return type in as well\n templ = symbol.declaration.templatePrefix\n if templ is not None:\n typeId = self.decl.get_ptr_suffix_id(version)\n returnTypeId = self.declSpecs.get_id(version)\n res.append(typeId)\n res.append(returnTypeId)\n res.append(self.decl.get_param_id(version))\n elif objectType == 'type': # just the name\n res.append(symbol.get_full_nested_name().get_id(version))\n else:\n print(objectType)\n assert False\n else: # only type encoding\n # the 'returnType' of a non-function type is simply just the last\n # type, i.e., for 'int*' it is 'int'\n returnTypeId = self.declSpecs.get_id(version)\n typeId = self.decl.get_type_id(version, returnTypeId)\n res.append(typeId)\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n declSpecs = transform(self.declSpecs)\n res.append(declSpecs)\n if self.decl.require_space_after_declSpecs() and len(declSpecs) > 0:\n res.append(' ')\n res.append(transform(self.decl))\n return ''.join(res)\n\n def get_type_declaration_prefix(self) -> str:\n if self.declSpecs.trailingTypeSpec:\n return 'typedef'\n else:\n return 'type'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.declSpecs.describe_signature(signode, 'markType', env, symbol)\n if (self.decl.require_space_after_declSpecs() and\n len(str(self.declSpecs)) > 0):\n signode += nodes.Text(' ')\n # for parameters that don't really declare new names we get 'markType',\n # this should not be propagated, but be 'noneIsName'.\n if mode == 'markType':\n mode = 'noneIsName'\n self.decl.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTemplateParamConstrainedTypeWithInit(ASTBase):\n def __init__(self, type: ASTType, init: ASTType) -> None:\n assert type\n self.type = type\n self.init = init\n\n @property\n def name(self) -> ASTNestedName:\n return self.type.name\n\n @property\n def isPack(self) -> bool:\n return self.type.isPack\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n # this is not part of the normal name mangling in C++\n assert version >= 2\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=False)\n else:\n return self.type.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = transform(self.type)\n if self.init:\n res += \" = \"\n res += transform(self.init)\n return res\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.type.describe_signature(signode, mode, env, symbol)\n if self.init:\n signode += nodes.Text(\" = \")\n self.init.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTypeWithInit(ASTBase):\n def __init__(self, type: ASTType, init: ASTInitializer) -> None:\n self.type = type\n self.init = init\n\n @property\n def name(self) -> ASTNestedName:\n return self.type.name\n\n @property\n def isPack(self) -> bool:\n return self.type.isPack\n\n def get_id(self, version: int, objectType: str = None,\n symbol: \"Symbol\" = None) -> str:\n if objectType != 'member':\n return self.type.get_id(version, objectType)\n if version == 1:\n return (symbol.get_full_nested_name().get_id(version) + '__' +\n self.type.get_id(version))\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.type))\n if self.init:\n res.append(transform(self.init))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.type.describe_signature(signode, mode, env, symbol)\n if self.init:\n self.init.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTypeUsing(ASTBase):\n def __init__(self, name: ASTNestedName, type: ASTType) -> None:\n self.name = name\n self.type = type\n\n def get_id(self, version: int, objectType: str = None,\n symbol: \"Symbol\" = None) -> str:\n if version == 1:\n raise NoOldIdError()\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.name))\n if self.type:\n res.append(' = ')\n res.append(transform(self.type))\n return ''.join(res)\n\n def get_type_declaration_prefix(self) -> str:\n return 'using'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.name.describe_signature(signode, mode, env, symbol=symbol)\n if self.type:\n signode += nodes.Text(' = ')\n self.type.describe_signature(signode, 'markType', env, symbol=symbol)\n\n\n# Other declarations\n##############################################################################################\n\nclass ASTConcept(ASTBase):\n def __init__(self, nestedName: ASTNestedName, initializer: ASTInitializer) -> None:\n self.nestedName = nestedName\n self.initializer = initializer\n\n @property\n def name(self) -> ASTNestedName:\n return self.nestedName\n\n def get_id(self, version: int, objectType: str = None,\n symbol: \"Symbol\" = None) -> str:\n if version == 1:\n raise NoOldIdError()\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = transform(self.nestedName)\n if self.initializer:\n res += transform(self.initializer)\n return res\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.nestedName.describe_signature(signode, mode, env, symbol)\n if self.initializer:\n self.initializer.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTBaseClass(ASTBase):\n def __init__(self, name: ASTNestedName, visibility: str,\n virtual: bool, pack: bool) -> None:\n self.name = name\n self.visibility = visibility\n self.virtual = virtual\n self.pack = pack\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n\n if self.visibility is not None:\n res.append(self.visibility)\n res.append(' ')\n if self.virtual:\n res.append('virtual ')\n res.append(transform(self.name))\n if self.pack:\n res.append('...')\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if self.visibility is not None:\n signode += addnodes.desc_annotation(self.visibility,\n self.visibility)\n signode += nodes.Text(' ')\n if self.virtual:\n signode += addnodes.desc_annotation('virtual', 'virtual')\n signode += nodes.Text(' ')\n self.name.describe_signature(signode, 'markType', env, symbol=symbol)\n if self.pack:\n signode += nodes.Text('...')\n\n\nclass ASTClass(ASTBase):\n def __init__(self, name: ASTNestedName, final: bool, bases: List[ASTBaseClass]) -> None:\n self.name = name\n self.final = final\n self.bases = bases\n\n def get_id(self, version: int, objectType: str, symbol: \"Symbol\") -> str:\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.name))\n if self.final:\n res.append(' final')\n if len(self.bases) > 0:\n res.append(' : ')\n first = True\n for b in self.bases:\n if not first:\n res.append(', ')\n first = False\n res.append(transform(b))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.name.describe_signature(signode, mode, env, symbol=symbol)\n if self.final:\n signode += nodes.Text(' ')\n signode += addnodes.desc_annotation('final', 'final')\n if len(self.bases) > 0:\n signode += nodes.Text(' : ')\n for b in self.bases:\n b.describe_signature(signode, mode, env, symbol=symbol)\n signode += nodes.Text(', ')\n signode.pop()\n\n\nclass ASTUnion(ASTBase):\n def __init__(self, name: ASTNestedName) -> None:\n self.name = name\n\n def get_id(self, version: int, objectType: str, symbol: \"Symbol\") -> str:\n if version == 1:\n raise NoOldIdError()\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.name)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.name.describe_signature(signode, mode, env, symbol=symbol)\n\n\nclass ASTEnum(ASTBase):\n def __init__(self, name: ASTNestedName, scoped: str,\n underlyingType: ASTType) -> None:\n self.name = name\n self.scoped = scoped\n self.underlyingType = underlyingType\n\n def get_id(self, version: int, objectType: str, symbol: \"Symbol\") -> str:\n if version == 1:\n raise NoOldIdError()\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.scoped:\n res.append(self.scoped)\n res.append(' ')\n res.append(transform(self.name))\n if self.underlyingType:\n res.append(' : ')\n res.append(transform(self.underlyingType))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n # self.scoped has been done by the CPPEnumObject\n self.name.describe_signature(signode, mode, env, symbol=symbol)\n if self.underlyingType:\n signode += nodes.Text(' : ')\n self.underlyingType.describe_signature(signode, 'noneIsName',\n env, symbol=symbol)\n\n\nclass ASTEnumerator(ASTBase):\n def __init__(self, name: ASTNestedName, init: ASTInitializer) -> None:\n self.name = name\n self.init = init\n\n def get_id(self, version: int, objectType: str, symbol: \"Symbol\") -> str:\n if version == 1:\n raise NoOldIdError()\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.name))\n if self.init:\n res.append(transform(self.init))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.name.describe_signature(signode, mode, env, symbol)\n if self.init:\n self.init.describe_signature(signode, 'markType', env, symbol)\n\n\n################################################################################\n# Templates\n################################################################################\n\n# Parameters\n################################################################################\n\nclass ASTTemplateParam(ASTBase):\n def get_identifier(self) -> ASTIdentifier:\n raise NotImplementedError(repr(self))\n\n def get_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def describe_signature(self, parentNode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n raise NotImplementedError(repr(self))\n\n\nclass ASTTemplateKeyParamPackIdDefault(ASTTemplateParam):\n def __init__(self, key: str, identifier: ASTIdentifier,\n parameterPack: bool, default: ASTType) -> None:\n assert key\n if parameterPack:\n assert default is None\n self.key = key\n self.identifier = identifier\n self.parameterPack = parameterPack\n self.default = default\n\n def get_identifier(self) -> ASTIdentifier:\n return self.identifier\n\n def get_id(self, version: int) -> str:\n assert version >= 2\n # this is not part of the normal name mangling in C++\n res = []\n if self.parameterPack:\n res.append('Dp')\n else:\n res.append('0') # we need to put something\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = [self.key]\n if self.parameterPack:\n if self.identifier:\n res.append(' ')\n res.append('...')\n if self.identifier:\n if not self.parameterPack:\n res.append(' ')\n res.append(transform(self.identifier))\n if self.default:\n res.append(' = ')\n res.append(transform(self.default))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode += nodes.Text(self.key)\n if self.parameterPack:\n if self.identifier:\n signode += nodes.Text(' ')\n signode += nodes.Text('...')\n if self.identifier:\n if not self.parameterPack:\n signode += nodes.Text(' ')\n self.identifier.describe_signature(signode, mode, env, '', '', symbol)\n if self.default:\n signode += nodes.Text(' = ')\n self.default.describe_signature(signode, 'markType', env, symbol)\n\n\nclass ASTTemplateParamType(ASTTemplateParam):\n def __init__(self, data: ASTTemplateKeyParamPackIdDefault) -> None:\n assert data\n self.data = data\n\n @property\n def name(self) -> ASTNestedName:\n id = self.get_identifier()\n return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False)\n\n @property\n def isPack(self) -> bool:\n return self.data.parameterPack\n\n def get_identifier(self) -> ASTIdentifier:\n return self.data.get_identifier()\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n # this is not part of the normal name mangling in C++\n assert version >= 2\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=False)\n else:\n return self.data.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.data)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.data.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTemplateParamTemplateType(ASTTemplateParam):\n def __init__(self, nestedParams: \"ASTTemplateParams\",\n data: ASTTemplateKeyParamPackIdDefault) -> None:\n assert nestedParams\n assert data\n self.nestedParams = nestedParams\n self.data = data\n\n @property\n def name(self) -> ASTNestedName:\n id = self.get_identifier()\n return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False)\n\n @property\n def isPack(self) -> bool:\n return self.data.parameterPack\n\n def get_identifier(self) -> ASTIdentifier:\n return self.data.get_identifier()\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n assert version >= 2\n # this is not part of the normal name mangling in C++\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=None)\n else:\n return self.nestedParams.get_id(version) + self.data.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.nestedParams) + transform(self.data)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.nestedParams.describe_signature(signode, 'noneIsName', env, symbol)\n signode += nodes.Text(' ')\n self.data.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTemplateParamNonType(ASTTemplateParam):\n def __init__(self,\n param: Union[ASTTypeWithInit,\n ASTTemplateParamConstrainedTypeWithInit]) -> None:\n assert param\n self.param = param\n\n @property\n def name(self) -> ASTNestedName:\n id = self.get_identifier()\n return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False)\n\n @property\n def isPack(self) -> bool:\n return self.param.isPack\n\n def get_identifier(self) -> ASTIdentifier:\n name = self.param.name\n if name:\n assert len(name.names) == 1\n assert name.names[0].identOrOp\n assert not name.names[0].templateArgs\n res = name.names[0].identOrOp\n assert isinstance(res, ASTIdentifier)\n return res\n else:\n return None\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n assert version >= 2\n # this is not part of the normal name mangling in C++\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=None)\n else:\n return '_' + self.param.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.param)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.param.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTemplateParams(ASTBase):\n def __init__(self, params: List[ASTTemplateParam]) -> None:\n assert params is not None\n self.params = params\n\n def get_id(self, version: int) -> str:\n assert version >= 2\n res = []\n res.append(\"I\")\n for param in self.params:\n res.append(param.get_id(version))\n res.append(\"E\")\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(\"template<\")\n res.append(\", \".join(transform(a) for a in self.params))\n res.append(\"> \")\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode += nodes.Text(\"template<\")\n first = True\n for param in self.params:\n if not first:\n signode += nodes.Text(\", \")\n first = False\n param.describe_signature(signode, mode, env, symbol)\n signode += nodes.Text(\">\")\n\n def describe_signature_as_introducer(\n self, parentNode: desc_signature, mode: str, env: \"BuildEnvironment\",\n symbol: \"Symbol\", lineSpec: bool) -> None:\n def makeLine(parentNode: desc_signature) -> addnodes.desc_signature_line:\n signode = addnodes.desc_signature_line()\n parentNode += signode\n signode.sphinx_line_type = 'templateParams'\n return signode\n lineNode = makeLine(parentNode)\n lineNode += nodes.Text(\"template<\")\n first = True\n for param in self.params:\n if not first:\n lineNode += nodes.Text(\", \")\n first = False\n if lineSpec:\n lineNode = makeLine(parentNode)\n param.describe_signature(lineNode, mode, env, symbol)\n if lineSpec and not first:\n lineNode = makeLine(parentNode)\n lineNode += nodes.Text(\">\")\n\n\n# Template introducers\n################################################################################\n\nclass ASTTemplateIntroductionParameter(ASTBase):\n def __init__(self, identifier: ASTIdentifier, parameterPack: bool) -> None:\n self.identifier = identifier\n self.parameterPack = parameterPack\n\n @property\n def name(self) -> ASTNestedName:\n id = self.get_identifier()\n return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False)\n\n @property\n def isPack(self) -> bool:\n return self.parameterPack\n\n def get_identifier(self) -> ASTIdentifier:\n return self.identifier\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n assert version >= 2\n # this is not part of the normal name mangling in C++\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=None)\n else:\n if self.parameterPack:\n return 'Dp'\n else:\n return '0' # we need to put something\n\n def get_id_as_arg(self, version: int) -> str:\n assert version >= 2\n # used for the implicit requires clause\n res = self.identifier.get_id(version)\n if self.parameterPack:\n return 'sp' + res\n else:\n return res\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.parameterPack:\n res.append('...')\n res.append(transform(self.identifier))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n if self.parameterPack:\n signode += nodes.Text('...')\n self.identifier.describe_signature(signode, mode, env, '', '', symbol)\n\n\nclass ASTTemplateIntroduction(ASTBase):\n def __init__(self, concept: ASTNestedName,\n params: List[ASTTemplateIntroductionParameter]) -> None:\n assert len(params) > 0\n self.concept = concept\n self.params = params\n\n def get_id(self, version: int) -> str:\n assert version >= 2\n # first do the same as a normal template parameter list\n res = []\n res.append(\"I\")\n for param in self.params:\n res.append(param.get_id(version))\n res.append(\"E\")\n # let's use X expr E, which is otherwise for constant template args\n res.append(\"X\")\n res.append(self.concept.get_id(version))\n res.append(\"I\")\n for param in self.params:\n res.append(param.get_id_as_arg(version))\n res.append(\"E\")\n res.append(\"E\")\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.concept))\n res.append('{')\n res.append(', '.join(transform(param) for param in self.params))\n res.append('} ')\n return ''.join(res)\n\n def describe_signature_as_introducer(\n self, parentNode: desc_signature, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\", lineSpec: bool) -> None:\n # Note: 'lineSpec' has no effect on template introductions.\n signode = addnodes.desc_signature_line()\n parentNode += signode\n signode.sphinx_line_type = 'templateIntroduction'\n self.concept.describe_signature(signode, 'markType', env, symbol)\n signode += nodes.Text('{')\n first = True\n for param in self.params:\n if not first:\n signode += nodes.Text(', ')\n first = False\n param.describe_signature(signode, mode, env, symbol)\n signode += nodes.Text('}')\n\n\nclass ASTTemplateDeclarationPrefix(ASTBase):\n def __init__(self,\n templates: List[Union[ASTTemplateParams,\n ASTTemplateIntroduction]]) -> None:\n # templates is None means it's an explicit instantiation of a variable\n self.templates = templates\n\n def get_id(self, version: int) -> str:\n assert version >= 2\n # this is not part of a normal name mangling system\n res = []\n for t in self.templates:\n res.append(t.get_id(version))\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n for t in self.templates:\n res.append(transform(t))\n return ''.join(res)\n\n def describe_signature(self, signode: desc_signature, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\", lineSpec: bool) -> None:\n verify_description_mode(mode)\n for t in self.templates:\n t.describe_signature_as_introducer(signode, 'lastIsName', env, symbol, lineSpec)\n\n\n################################################################################\n################################################################################\n\nclass ASTDeclaration(ASTBase):\n def __init__(self, objectType: str, directiveType: str, visibility: str,\n templatePrefix: ASTTemplateDeclarationPrefix, declaration: Any) -> None:\n self.objectType = objectType\n self.directiveType = directiveType\n self.visibility = visibility\n self.templatePrefix = templatePrefix\n self.declaration = declaration\n\n self.symbol = None # type: Symbol\n # set by CPPObject._add_enumerator_to_parent\n self.enumeratorScopedSymbol = None # type: Symbol\n\n def clone(self) -> \"ASTDeclaration\":\n if self.templatePrefix:\n templatePrefixClone = self.templatePrefix.clone()\n else:\n templatePrefixClone = None\n return ASTDeclaration(self.objectType, self.directiveType,\n self.visibility, templatePrefixClone,\n self.declaration.clone())\n\n @property\n def name(self) -> ASTNestedName:\n return self.declaration.name\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n if self.objectType != 'function':\n return None\n return self.declaration.function_params\n\n def get_id(self, version: int, prefixed: bool = True) -> str:\n if version == 1:\n if self.templatePrefix:\n raise NoOldIdError()\n if self.objectType == 'enumerator' and self.enumeratorScopedSymbol:\n return self.enumeratorScopedSymbol.declaration.get_id(version)\n return self.declaration.get_id(version, self.objectType, self.symbol)\n # version >= 2\n if self.objectType == 'enumerator' and self.enumeratorScopedSymbol:\n return self.enumeratorScopedSymbol.declaration.get_id(version, prefixed)\n if prefixed:\n res = [_id_prefix[version]]\n else:\n res = []\n if self.templatePrefix:\n res.append(self.templatePrefix.get_id(version))\n res.append(self.declaration.get_id(version, self.objectType, self.symbol))\n return ''.join(res)\n\n def get_newest_id(self) -> str:\n return self.get_id(_max_id, True)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.visibility and self.visibility != \"public\":\n res.append(self.visibility)\n res.append(' ')\n if self.templatePrefix:\n res.append(transform(self.templatePrefix))\n res.append(transform(self.declaration))\n return ''.join(res)\n\n def describe_signature(self, signode: desc_signature, mode: str,\n env: \"BuildEnvironment\", options: Dict) -> None:\n verify_description_mode(mode)\n assert self.symbol\n # The caller of the domain added a desc_signature node.\n # Always enable multiline:\n signode['is_multiline'] = True\n # Put each line in a desc_signature_line node.\n mainDeclNode = addnodes.desc_signature_line()\n mainDeclNode.sphinx_line_type = 'declarator'\n mainDeclNode['add_permalink'] = not self.symbol.isRedeclaration\n\n if self.templatePrefix:\n self.templatePrefix.describe_signature(signode, mode, env,\n symbol=self.symbol,\n lineSpec=options.get('tparam-line-spec'))\n signode += mainDeclNode\n if self.visibility and self.visibility != \"public\":\n mainDeclNode += addnodes.desc_annotation(self.visibility + \" \",\n self.visibility + \" \")\n if self.objectType == 'type':\n prefix = self.declaration.get_type_declaration_prefix()\n prefix += ' '\n mainDeclNode += addnodes.desc_annotation(prefix, prefix)\n elif self.objectType == 'concept':\n mainDeclNode += addnodes.desc_annotation('concept ', 'concept ')\n elif self.objectType == 'member':\n pass\n elif self.objectType == 'function':\n pass\n elif self.objectType == 'class':\n assert self.directiveType in ('class', 'struct')\n prefix = self.directiveType + ' '\n mainDeclNode += addnodes.desc_annotation(prefix, prefix)\n elif self.objectType == 'union':\n mainDeclNode += addnodes.desc_annotation('union ', 'union ')\n elif self.objectType == 'enum':\n if self.directiveType == 'enum':\n prefix = 'enum '\n elif self.directiveType == 'enum-class':\n prefix = 'enum class '\n elif self.directiveType == 'enum-struct':\n prefix = 'enum struct '\n else:\n assert False # wrong directiveType used\n mainDeclNode += addnodes.desc_annotation(prefix, prefix)\n elif self.objectType == 'enumerator':\n mainDeclNode += addnodes.desc_annotation('enumerator ', 'enumerator ')\n else:\n assert False\n self.declaration.describe_signature(mainDeclNode, mode, env, self.symbol)\n\n\nclass ASTNamespace(ASTBase):\n def __init__(self, nestedName: ASTNestedName,\n templatePrefix: ASTTemplateDeclarationPrefix) -> None:\n self.nestedName = nestedName\n self.templatePrefix = templatePrefix\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.templatePrefix:\n res.append(transform(self.templatePrefix))\n res.append(transform(self.nestedName))\n return ''.join(res)\n\n\nclass SymbolLookupResult:\n def __init__(self, symbols: Iterator[\"Symbol\"], parentSymbol: \"Symbol\",\n identOrOp: Union[ASTIdentifier, ASTOperator], templateParams: Any,\n templateArgs: ASTTemplateArgs) -> None:\n self.symbols = symbols\n self.parentSymbol = parentSymbol\n self.identOrOp = identOrOp\n self.templateParams = templateParams\n self.templateArgs = templateArgs\n\n\nclass LookupKey:\n def __init__(self, data: List[Tuple[ASTNestedNameElement,\n Union[ASTTemplateParams,\n ASTTemplateIntroduction],\n str]]) -> None:\n self.data = data\n\n\nclass Symbol:\n debug_indent = 0\n debug_indent_string = \" \"\n debug_lookup = False\n debug_show_tree = False\n\n @staticmethod\n def debug_print(*args: Any) -> None:\n print(Symbol.debug_indent_string * Symbol.debug_indent, end=\"\")\n print(*args)\n\n def _assert_invariants(self) -> None:\n if not self.parent:\n # parent == None means global scope, so declaration means a parent\n assert not self.identOrOp\n assert not self.templateParams\n assert not self.templateArgs\n assert not self.declaration\n assert not self.docname\n else:\n if self.declaration:\n assert self.docname\n\n def __setattr__(self, key: str, value: Any) -> None:\n if key == \"children\":\n assert False\n else:\n return super().__setattr__(key, value)\n\n def __init__(self, parent: \"Symbol\", identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Union[ASTTemplateParams, ASTTemplateIntroduction],\n templateArgs: Any, declaration: ASTDeclaration, docname: str) -> None:\n self.parent = parent\n # declarations in a single directive are linked together\n self.siblingAbove = None # type: Symbol\n self.siblingBelow = None # type: Symbol\n self.identOrOp = identOrOp\n self.templateParams = templateParams # template<templateParams>\n self.templateArgs = templateArgs # identifier<templateArgs>\n self.declaration = declaration\n self.docname = docname\n self.isRedeclaration = False\n self._assert_invariants()\n\n # Remember to modify Symbol.remove if modifications to the parent change.\n self._children = [] # type: List[Symbol]\n self._anonChildren = [] # type: List[Symbol]\n # note: _children includes _anonChildren\n if self.parent:\n self.parent._children.append(self)\n if self.declaration:\n self.declaration.symbol = self\n\n # Do symbol addition after self._children has been initialised.\n self._add_template_and_function_params()\n\n def _fill_empty(self, declaration: ASTDeclaration, docname: str) -> None:\n self._assert_invariants()\n assert not self.declaration\n assert not self.docname\n assert declaration\n assert docname\n self.declaration = declaration\n self.declaration.symbol = self\n self.docname = docname\n self._assert_invariants()\n # and symbol addition should be done as well\n self._add_template_and_function_params()\n\n def _add_template_and_function_params(self) -> None:\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"_add_template_and_function_params:\")\n # Note: we may be called from _fill_empty, so the symbols we want\n # to add may actually already be present (as empty symbols).\n\n # add symbols for the template params\n if self.templateParams:\n for tp in self.templateParams.params:\n if not tp.get_identifier():\n continue\n # only add a declaration if we our self are from a declaration\n if self.declaration:\n decl = ASTDeclaration('templateParam', None, None, None, tp)\n else:\n decl = None\n nne = ASTNestedNameElement(tp.get_identifier(), None)\n nn = ASTNestedName([nne], [False], rooted=False)\n self._add_symbols(nn, [], decl, self.docname)\n # add symbols for function parameters, if any\n if self.declaration is not None and self.declaration.function_params is not None:\n for fp in self.declaration.function_params:\n if fp.arg is None:\n continue\n nn = fp.arg.name\n if nn is None:\n continue\n # (comparing to the template params: we have checked that we are a declaration)\n decl = ASTDeclaration('functionParam', None, None, None, fp)\n assert not nn.rooted\n assert len(nn.names) == 1\n self._add_symbols(nn, [], decl, self.docname)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n\n def remove(self) -> None:\n if self.parent is None:\n return\n assert self in self.parent._children\n self.parent._children.remove(self)\n self.parent = None\n\n def clear_doc(self, docname: str) -> None:\n newChildren = [] # type: List[Symbol]\n for sChild in self._children:\n sChild.clear_doc(docname)\n if sChild.declaration and sChild.docname == docname:\n sChild.declaration = None\n sChild.docname = None\n if sChild.siblingAbove is not None:\n sChild.siblingAbove.siblingBelow = sChild.siblingBelow\n if sChild.siblingBelow is not None:\n sChild.siblingBelow.siblingAbove = sChild.siblingAbove\n sChild.siblingAbove = None\n sChild.siblingBelow = None\n newChildren.append(sChild)\n self._children = newChildren\n\n def get_all_symbols(self) -> Iterator[Any]:\n yield self\n for sChild in self._children:\n for s in sChild.get_all_symbols():\n yield s\n\n @property\n def children_recurse_anon(self) -> Generator[\"Symbol\", None, None]:\n for c in self._children:\n yield c\n if not c.identOrOp.is_anon():\n continue\n\n yield from c.children_recurse_anon\n\n def get_lookup_key(self) -> \"LookupKey\":\n # The pickle files for the environment and for each document are distinct.\n # The environment has all the symbols, but the documents has xrefs that\n # must know their scope. A lookup key is essentially a specification of\n # how to find a specific symbol.\n symbols = []\n s = self\n while s.parent:\n symbols.append(s)\n s = s.parent\n symbols.reverse()\n key = []\n for s in symbols:\n nne = ASTNestedNameElement(s.identOrOp, s.templateArgs)\n if s.declaration is not None:\n key.append((nne, s.templateParams, s.declaration.get_newest_id()))\n else:\n key.append((nne, s.templateParams, None))\n return LookupKey(key)\n\n def get_full_nested_name(self) -> ASTNestedName:\n symbols = []\n s = self\n while s.parent:\n symbols.append(s)\n s = s.parent\n symbols.reverse()\n names = []\n templates = []\n for s in symbols:\n names.append(ASTNestedNameElement(s.identOrOp, s.templateArgs))\n templates.append(False)\n return ASTNestedName(names, templates, rooted=False)\n\n def _find_first_named_symbol(self, identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Any, templateArgs: ASTTemplateArgs,\n templateShorthand: bool, matchSelf: bool,\n recurseInAnon: bool, correctPrimaryTemplateArgs: bool\n ) -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_print(\"_find_first_named_symbol ->\")\n res = self._find_named_symbols(identOrOp, templateParams, templateArgs,\n templateShorthand, matchSelf, recurseInAnon,\n correctPrimaryTemplateArgs,\n searchInSiblings=False)\n try:\n return next(res)\n except StopIteration:\n return None\n\n def _find_named_symbols(self, identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Any, templateArgs: ASTTemplateArgs,\n templateShorthand: bool, matchSelf: bool,\n recurseInAnon: bool, correctPrimaryTemplateArgs: bool,\n searchInSiblings: bool) -> Iterator[\"Symbol\"]:\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"_find_named_symbols:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"self:\")\n print(self.to_string(Symbol.debug_indent + 1), end=\"\")\n Symbol.debug_print(\"identOrOp: \", identOrOp)\n Symbol.debug_print(\"templateParams: \", templateParams)\n Symbol.debug_print(\"templateArgs: \", templateArgs)\n Symbol.debug_print(\"templateShorthand: \", templateShorthand)\n Symbol.debug_print(\"matchSelf: \", matchSelf)\n Symbol.debug_print(\"recurseInAnon: \", recurseInAnon)\n Symbol.debug_print(\"correctPrimaryTemplateAargs:\", correctPrimaryTemplateArgs)\n Symbol.debug_print(\"searchInSiblings: \", searchInSiblings)\n\n def isSpecialization() -> bool:\n # the names of the template parameters must be given exactly as args\n # and params that are packs must in the args be the name expanded\n if len(templateParams.params) != len(templateArgs.args):\n return True\n # having no template params and no arguments is also a specialization\n if len(templateParams.params) == 0:\n return True\n for i in range(len(templateParams.params)):\n param = templateParams.params[i]\n arg = templateArgs.args[i]\n # TODO: doing this by string manipulation is probably not the most efficient\n paramName = str(param.name)\n argTxt = str(arg)\n isArgPackExpansion = argTxt.endswith('...')\n if param.isPack != isArgPackExpansion:\n return True\n argName = argTxt[:-3] if isArgPackExpansion else argTxt\n if paramName != argName:\n return True\n return False\n if correctPrimaryTemplateArgs:\n if templateParams is not None and templateArgs is not None:\n # If both are given, but it's not a specialization, then do lookup as if\n # there is no argument list.\n # For example: template<typename T> int A<T>::var;\n if not isSpecialization():\n templateArgs = None\n\n def matches(s: \"Symbol\") -> bool:\n if s.identOrOp != identOrOp:\n return False\n if (s.templateParams is None) != (templateParams is None):\n if templateParams is not None:\n # we query with params, they must match params\n return False\n if not templateShorthand:\n # we don't query with params, and we do care about them\n return False\n if templateParams:\n # TODO: do better comparison\n if str(s.templateParams) != str(templateParams):\n return False\n if (s.templateArgs is None) != (templateArgs is None):\n return False\n if s.templateArgs:\n # TODO: do better comparison\n if str(s.templateArgs) != str(templateArgs):\n return False\n return True\n\n def candidates() -> Generator[Symbol, None, None]:\n s = self\n if Symbol.debug_lookup:\n Symbol.debug_print(\"searching in self:\")\n print(s.to_string(Symbol.debug_indent + 1), end=\"\")\n while True:\n if matchSelf:\n yield s\n if recurseInAnon:\n yield from s.children_recurse_anon\n else:\n yield from s._children\n\n if s.siblingAbove is None:\n break\n s = s.siblingAbove\n if Symbol.debug_lookup:\n Symbol.debug_print(\"searching in sibling:\")\n print(s.to_string(Symbol.debug_indent + 1), end=\"\")\n\n for s in candidates():\n if Symbol.debug_lookup:\n Symbol.debug_print(\"candidate:\")\n print(s.to_string(Symbol.debug_indent + 1), end=\"\")\n if matches(s):\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"matches\")\n Symbol.debug_indent -= 3\n yield s\n if Symbol.debug_lookup:\n Symbol.debug_indent += 2\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n\n def _symbol_lookup(self, nestedName: ASTNestedName, templateDecls: List[Any],\n onMissingQualifiedSymbol: Callable[[\"Symbol\", Union[ASTIdentifier, ASTOperator], Any, ASTTemplateArgs], \"Symbol\"], # NOQA\n strictTemplateParamArgLists: bool, ancestorLookupType: str,\n templateShorthand: bool, matchSelf: bool,\n recurseInAnon: bool, correctPrimaryTemplateArgs: bool,\n searchInSiblings: bool) -> SymbolLookupResult:\n # ancestorLookupType: if not None, specifies the target type of the lookup\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"_symbol_lookup:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"self:\")\n print(self.to_string(Symbol.debug_indent + 1), end=\"\")\n Symbol.debug_print(\"nestedName: \", nestedName)\n Symbol.debug_print(\"templateDecls: \", templateDecls)\n Symbol.debug_print(\"strictTemplateParamArgLists:\", strictTemplateParamArgLists)\n Symbol.debug_print(\"ancestorLookupType:\", ancestorLookupType)\n Symbol.debug_print(\"templateShorthand: \", templateShorthand)\n Symbol.debug_print(\"matchSelf: \", matchSelf)\n Symbol.debug_print(\"recurseInAnon: \", recurseInAnon)\n Symbol.debug_print(\"correctPrimaryTemplateArgs: \", correctPrimaryTemplateArgs)\n Symbol.debug_print(\"searchInSiblings: \", searchInSiblings)\n\n if strictTemplateParamArgLists:\n # Each template argument list must have a template parameter list.\n # But to declare a template there must be an additional template parameter list.\n assert (nestedName.num_templates() == len(templateDecls) or\n nestedName.num_templates() + 1 == len(templateDecls))\n else:\n assert len(templateDecls) <= nestedName.num_templates() + 1\n\n names = nestedName.names\n\n # find the right starting point for lookup\n parentSymbol = self\n if nestedName.rooted:\n while parentSymbol.parent:\n parentSymbol = parentSymbol.parent\n if ancestorLookupType is not None:\n # walk up until we find the first identifier\n firstName = names[0]\n if not firstName.is_operator():\n while parentSymbol.parent:\n if parentSymbol.find_identifier(firstName.identOrOp,\n matchSelf=matchSelf,\n recurseInAnon=recurseInAnon,\n searchInSiblings=searchInSiblings):\n # if we are in the scope of a constructor but wants to\n # reference the class we need to walk one extra up\n if (len(names) == 1 and ancestorLookupType == 'class' and matchSelf and\n parentSymbol.parent and\n parentSymbol.parent.identOrOp == firstName.identOrOp):\n pass\n else:\n break\n parentSymbol = parentSymbol.parent\n\n if Symbol.debug_lookup:\n Symbol.debug_print(\"starting point:\")\n print(parentSymbol.to_string(Symbol.debug_indent + 1), end=\"\")\n\n # and now the actual lookup\n iTemplateDecl = 0\n for name in names[:-1]:\n identOrOp = name.identOrOp\n templateArgs = name.templateArgs\n if strictTemplateParamArgLists:\n # there must be a parameter list\n if templateArgs:\n assert iTemplateDecl < len(templateDecls)\n templateParams = templateDecls[iTemplateDecl]\n iTemplateDecl += 1\n else:\n templateParams = None\n else:\n # take the next template parameter list if there is one\n # otherwise it's ok\n if templateArgs and iTemplateDecl < len(templateDecls):\n templateParams = templateDecls[iTemplateDecl]\n iTemplateDecl += 1\n else:\n templateParams = None\n\n symbol = parentSymbol._find_first_named_symbol(\n identOrOp,\n templateParams, templateArgs,\n templateShorthand=templateShorthand,\n matchSelf=matchSelf,\n recurseInAnon=recurseInAnon,\n correctPrimaryTemplateArgs=correctPrimaryTemplateArgs)\n if symbol is None:\n symbol = onMissingQualifiedSymbol(parentSymbol, identOrOp,\n templateParams, templateArgs)\n if symbol is None:\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return None\n # We have now matched part of a nested name, and need to match more\n # so even if we should matchSelf before, we definitely shouldn't\n # even more. (see also issue #2666)\n matchSelf = False\n parentSymbol = symbol\n\n if Symbol.debug_lookup:\n Symbol.debug_print(\"handle last name from:\")\n print(parentSymbol.to_string(Symbol.debug_indent + 1), end=\"\")\n\n # handle the last name\n name = names[-1]\n identOrOp = name.identOrOp\n templateArgs = name.templateArgs\n if iTemplateDecl < len(templateDecls):\n assert iTemplateDecl + 1 == len(templateDecls)\n templateParams = templateDecls[iTemplateDecl]\n else:\n assert iTemplateDecl == len(templateDecls)\n templateParams = None\n\n symbols = parentSymbol._find_named_symbols(\n identOrOp, templateParams, templateArgs,\n templateShorthand=templateShorthand, matchSelf=matchSelf,\n recurseInAnon=recurseInAnon, correctPrimaryTemplateArgs=False,\n searchInSiblings=searchInSiblings)\n if Symbol.debug_lookup:\n symbols = list(symbols) # type: ignore\n Symbol.debug_indent -= 2\n return SymbolLookupResult(symbols, parentSymbol,\n identOrOp, templateParams, templateArgs)\n\n def _add_symbols(self, nestedName: ASTNestedName, templateDecls: List[Any],\n declaration: ASTDeclaration, docname: str) -> \"Symbol\":\n # Used for adding a whole path of symbols, where the last may or may not\n # be an actual declaration.\n\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"_add_symbols:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"tdecls:\", templateDecls)\n Symbol.debug_print(\"nn: \", nestedName)\n Symbol.debug_print(\"decl: \", declaration)\n Symbol.debug_print(\"doc: \", docname)\n\n def onMissingQualifiedSymbol(parentSymbol: \"Symbol\",\n identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Any, templateArgs: ASTTemplateArgs\n ) -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"_add_symbols, onMissingQualifiedSymbol:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"templateParams:\", templateParams)\n Symbol.debug_print(\"identOrOp: \", identOrOp)\n Symbol.debug_print(\"templateARgs: \", templateArgs)\n Symbol.debug_indent -= 2\n return Symbol(parent=parentSymbol, identOrOp=identOrOp,\n templateParams=templateParams,\n templateArgs=templateArgs, declaration=None,\n docname=None)\n\n lookupResult = self._symbol_lookup(nestedName, templateDecls,\n onMissingQualifiedSymbol,\n strictTemplateParamArgLists=True,\n ancestorLookupType=None,\n templateShorthand=False,\n matchSelf=False,\n recurseInAnon=False,\n correctPrimaryTemplateArgs=True,\n searchInSiblings=False)\n assert lookupResult is not None # we create symbols all the way, so that can't happen\n symbols = list(lookupResult.symbols)\n if len(symbols) == 0:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"_add_symbols, result, no symbol:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"templateParams:\", lookupResult.templateParams)\n Symbol.debug_print(\"identOrOp: \", lookupResult.identOrOp)\n Symbol.debug_print(\"templateArgs: \", lookupResult.templateArgs)\n Symbol.debug_print(\"declaration: \", declaration)\n Symbol.debug_print(\"docname: \", docname)\n Symbol.debug_indent -= 1\n symbol = Symbol(parent=lookupResult.parentSymbol,\n identOrOp=lookupResult.identOrOp,\n templateParams=lookupResult.templateParams,\n templateArgs=lookupResult.templateArgs,\n declaration=declaration,\n docname=docname)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return symbol\n\n if Symbol.debug_lookup:\n Symbol.debug_print(\"_add_symbols, result, symbols:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"number symbols:\", len(symbols))\n Symbol.debug_indent -= 1\n\n if not declaration:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"no delcaration\")\n Symbol.debug_indent -= 2\n # good, just a scope creation\n # TODO: what if we have more than one symbol?\n return symbols[0]\n\n noDecl = []\n withDecl = []\n dupDecl = []\n for s in symbols:\n if s.declaration is None:\n noDecl.append(s)\n elif s.isRedeclaration:\n dupDecl.append(s)\n else:\n withDecl.append(s)\n if Symbol.debug_lookup:\n Symbol.debug_print(\"#noDecl: \", len(noDecl))\n Symbol.debug_print(\"#withDecl:\", len(withDecl))\n Symbol.debug_print(\"#dupDecl: \", len(dupDecl))\n # With partial builds we may start with a large symbol tree stripped of declarations.\n # Essentially any combination of noDecl, withDecl, and dupDecls seems possible.\n # TODO: make partial builds fully work. What should happen when the primary symbol gets\n # deleted, and other duplicates exist? The full document should probably be rebuild.\n\n # First check if one of those with a declaration matches.\n # If it's a function, we need to compare IDs,\n # otherwise there should be only one symbol with a declaration.\n def makeCandSymbol() -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_print(\"begin: creating candidate symbol\")\n symbol = Symbol(parent=lookupResult.parentSymbol,\n identOrOp=lookupResult.identOrOp,\n templateParams=lookupResult.templateParams,\n templateArgs=lookupResult.templateArgs,\n declaration=declaration,\n docname=docname)\n if Symbol.debug_lookup:\n Symbol.debug_print(\"end: creating candidate symbol\")\n return symbol\n if len(withDecl) == 0:\n candSymbol = None\n else:\n candSymbol = makeCandSymbol()\n\n def handleDuplicateDeclaration(symbol: \"Symbol\", candSymbol: \"Symbol\") -> None:\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"redeclaration\")\n Symbol.debug_indent -= 1\n Symbol.debug_indent -= 2\n # Redeclaration of the same symbol.\n # Let the new one be there, but raise an error to the client\n # so it can use the real symbol as subscope.\n # This will probably result in a duplicate id warning.\n candSymbol.isRedeclaration = True\n raise _DuplicateSymbolError(symbol, declaration)\n\n if declaration.objectType != \"function\":\n assert len(withDecl) <= 1\n handleDuplicateDeclaration(withDecl[0], candSymbol)\n # (not reachable)\n\n # a function, so compare IDs\n candId = declaration.get_newest_id()\n if Symbol.debug_lookup:\n Symbol.debug_print(\"candId:\", candId)\n for symbol in withDecl:\n oldId = symbol.declaration.get_newest_id()\n if Symbol.debug_lookup:\n Symbol.debug_print(\"oldId: \", oldId)\n if candId == oldId:\n handleDuplicateDeclaration(symbol, candSymbol)\n # (not reachable)\n # no candidate symbol found with matching ID\n # if there is an empty symbol, fill that one\n if len(noDecl) == 0:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"no match, no empty, candSybmol is not None?:\", candSymbol is not None) # NOQA\n Symbol.debug_indent -= 2\n if candSymbol is not None:\n return candSymbol\n else:\n return makeCandSymbol()\n else:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"no match, but fill an empty declaration, candSybmol is not None?:\", candSymbol is not None) # NOQA\n Symbol.debug_indent -= 2\n if candSymbol is not None:\n candSymbol.remove()\n # assert len(noDecl) == 1\n # TODO: enable assertion when we at some point find out how to do cleanup\n # for now, just take the first one, it should work fine ... right?\n symbol = noDecl[0]\n # If someone first opened the scope, and then later\n # declares it, e.g,\n # .. namespace:: Test\n # .. namespace:: nullptr\n # .. class:: Test\n symbol._fill_empty(declaration, docname)\n return symbol\n\n def merge_with(self, other: \"Symbol\", docnames: List[str],\n env: \"BuildEnvironment\") -> None:\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"merge_with:\")\n assert other is not None\n\n def unconditionalAdd(self, otherChild):\n # TODO: hmm, should we prune by docnames?\n self._children.append(otherChild)\n otherChild.parent = self\n otherChild._assert_invariants()\n\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n for otherChild in other._children:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"otherChild:\\n\", otherChild.to_string(Symbol.debug_indent))\n Symbol.debug_indent += 1\n if otherChild.isRedeclaration:\n unconditionalAdd(self, otherChild)\n if Symbol.debug_lookup:\n Symbol.debug_print(\"isRedeclaration\")\n Symbol.debug_indent -= 1\n continue\n candiateIter = self._find_named_symbols(\n identOrOp=otherChild.identOrOp,\n templateParams=otherChild.templateParams,\n templateArgs=otherChild.templateArgs,\n templateShorthand=False, matchSelf=False,\n recurseInAnon=False, correctPrimaryTemplateArgs=False,\n searchInSiblings=False)\n candidates = list(candiateIter)\n\n if Symbol.debug_lookup:\n Symbol.debug_print(\"raw candidate symbols:\", len(candidates))\n symbols = [s for s in candidates if not s.isRedeclaration]\n if Symbol.debug_lookup:\n Symbol.debug_print(\"non-duplicate candidate symbols:\", len(symbols))\n\n if len(symbols) == 0:\n unconditionalAdd(self, otherChild)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n continue\n\n ourChild = None\n if otherChild.declaration is None:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"no declaration in other child\")\n ourChild = symbols[0]\n else:\n queryId = otherChild.declaration.get_newest_id()\n if Symbol.debug_lookup:\n Symbol.debug_print(\"queryId: \", queryId)\n for symbol in symbols:\n if symbol.declaration is None:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"empty candidate\")\n # if in the end we have non matching, but have an empty one,\n # then just continue with that\n ourChild = symbol\n continue\n candId = symbol.declaration.get_newest_id()\n if Symbol.debug_lookup:\n Symbol.debug_print(\"candidate:\", candId)\n if candId == queryId:\n ourChild = symbol\n break\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n if ourChild is None:\n unconditionalAdd(self, otherChild)\n continue\n if otherChild.declaration and otherChild.docname in docnames:\n if not ourChild.declaration:\n ourChild._fill_empty(otherChild.declaration, otherChild.docname)\n elif ourChild.docname != otherChild.docname:\n name = str(ourChild.declaration)\n msg = __(\"Duplicate declaration, also defined in '%s'.\\n\"\n \"Declaration is '%s'.\")\n msg = msg % (ourChild.docname, name)\n logger.warning(msg, location=otherChild.docname)\n else:\n # Both have declarations, and in the same docname.\n # This can apparently happen, it should be safe to\n # just ignore it, right?\n # Hmm, only on duplicate declarations, right?\n msg = \"Internal C++ domain error during symbol merging.\\n\"\n msg += \"ourChild:\\n\" + ourChild.to_string(1)\n msg += \"\\notherChild:\\n\" + otherChild.to_string(1)\n logger.warning(msg, location=otherChild.docname)\n ourChild.merge_with(otherChild, docnames, env)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n\n def add_name(self, nestedName: ASTNestedName,\n templatePrefix: ASTTemplateDeclarationPrefix = None) -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"add_name:\")\n if templatePrefix:\n templateDecls = templatePrefix.templates\n else:\n templateDecls = []\n res = self._add_symbols(nestedName, templateDecls,\n declaration=None, docname=None)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n return res\n\n def add_declaration(self, declaration: ASTDeclaration, docname: str) -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"add_declaration:\")\n assert declaration\n assert docname\n nestedName = declaration.name\n if declaration.templatePrefix:\n templateDecls = declaration.templatePrefix.templates\n else:\n templateDecls = []\n res = self._add_symbols(nestedName, templateDecls, declaration, docname)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n return res\n\n def find_identifier(self, identOrOp: Union[ASTIdentifier, ASTOperator],\n matchSelf: bool, recurseInAnon: bool, searchInSiblings: bool\n ) -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"find_identifier:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"identOrOp: \", identOrOp)\n Symbol.debug_print(\"matchSelf: \", matchSelf)\n Symbol.debug_print(\"recurseInAnon: \", recurseInAnon)\n Symbol.debug_print(\"searchInSiblings:\", searchInSiblings)\n print(self.to_string(Symbol.debug_indent + 1), end=\"\")\n Symbol.debug_indent -= 2\n current = self\n while current is not None:\n if Symbol.debug_lookup:\n Symbol.debug_indent += 2\n Symbol.debug_print(\"trying:\")\n print(current.to_string(Symbol.debug_indent + 1), end=\"\")\n Symbol.debug_indent -= 2\n if matchSelf and current.identOrOp == identOrOp:\n return current\n children = current.children_recurse_anon if recurseInAnon else current._children\n for s in children:\n if s.identOrOp == identOrOp:\n return s\n if not searchInSiblings:\n break\n current = current.siblingAbove\n return None\n\n def direct_lookup(self, key: \"LookupKey\") -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"direct_lookup:\")\n Symbol.debug_indent += 1\n s = self\n for name, templateParams, id_ in key.data:\n if id_ is not None:\n res = None\n for cand in s._children:\n if cand.declaration is None:\n continue\n if cand.declaration.get_newest_id() == id_:\n res = cand\n break\n s = res\n else:\n identOrOp = name.identOrOp\n templateArgs = name.templateArgs\n s = s._find_first_named_symbol(identOrOp,\n templateParams, templateArgs,\n templateShorthand=False,\n matchSelf=False,\n recurseInAnon=False,\n correctPrimaryTemplateArgs=False)\n if Symbol.debug_lookup:\n Symbol.debug_print(\"name: \", name)\n Symbol.debug_print(\"templateParams:\", templateParams)\n Symbol.debug_print(\"id: \", id_)\n if s is not None:\n print(s.to_string(Symbol.debug_indent + 1), end=\"\")\n else:\n Symbol.debug_print(\"not found\")\n if s is None:\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return None\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return s\n\n def find_name(self, nestedName: ASTNestedName, templateDecls: List[Any],\n typ: str, templateShorthand: bool, matchSelf: bool,\n recurseInAnon: bool, searchInSiblings: bool) -> Tuple[List[\"Symbol\"], str]:\n # templateShorthand: missing template parameter lists for templates is ok\n # If the first component is None,\n # then the second component _may_ be a string explaining why.\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"find_name:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"self:\")\n print(self.to_string(Symbol.debug_indent + 1), end=\"\")\n Symbol.debug_print(\"nestedName: \", nestedName)\n Symbol.debug_print(\"templateDecls: \", templateDecls)\n Symbol.debug_print(\"typ: \", typ)\n Symbol.debug_print(\"templateShorthand:\", templateShorthand)\n Symbol.debug_print(\"matchSelf: \", matchSelf)\n Symbol.debug_print(\"recurseInAnon: \", recurseInAnon)\n Symbol.debug_print(\"searchInSiblings: \", searchInSiblings)\n\n class QualifiedSymbolIsTemplateParam(Exception):\n pass\n\n def onMissingQualifiedSymbol(parentSymbol: \"Symbol\",\n identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Any,\n templateArgs: ASTTemplateArgs) -> \"Symbol\":\n # TODO: Maybe search without template args?\n # Though, the correctPrimaryTemplateArgs does\n # that for primary templates.\n # Is there another case where it would be good?\n if parentSymbol.declaration is not None:\n if parentSymbol.declaration.objectType == 'templateParam':\n raise QualifiedSymbolIsTemplateParam()\n return None\n\n try:\n lookupResult = self._symbol_lookup(nestedName, templateDecls,\n onMissingQualifiedSymbol,\n strictTemplateParamArgLists=False,\n ancestorLookupType=typ,\n templateShorthand=templateShorthand,\n matchSelf=matchSelf,\n recurseInAnon=recurseInAnon,\n correctPrimaryTemplateArgs=False,\n searchInSiblings=searchInSiblings)\n except QualifiedSymbolIsTemplateParam:\n return None, \"templateParamInQualified\"\n\n if lookupResult is None:\n # if it was a part of the qualification that could not be found\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return None, None\n\n res = list(lookupResult.symbols)\n if len(res) != 0:\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return res, None\n\n if lookupResult.parentSymbol.declaration is not None:\n if lookupResult.parentSymbol.declaration.objectType == 'templateParam':\n return None, \"templateParamInQualified\"\n\n # try without template params and args\n symbol = lookupResult.parentSymbol._find_first_named_symbol(\n lookupResult.identOrOp, None, None,\n templateShorthand=templateShorthand, matchSelf=matchSelf,\n recurseInAnon=recurseInAnon, correctPrimaryTemplateArgs=False)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n if symbol is not None:\n return [symbol], None\n else:\n return None, None\n\n def find_declaration(self, declaration: ASTDeclaration, typ: str, templateShorthand: bool,\n matchSelf: bool, recurseInAnon: bool) -> \"Symbol\":\n # templateShorthand: missing template parameter lists for templates is ok\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"find_declaration:\")\n nestedName = declaration.name\n if declaration.templatePrefix:\n templateDecls = declaration.templatePrefix.templates\n else:\n templateDecls = []\n\n def onMissingQualifiedSymbol(parentSymbol: \"Symbol\",\n identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Any,\n templateArgs: ASTTemplateArgs) -> \"Symbol\":\n return None\n\n lookupResult = self._symbol_lookup(nestedName, templateDecls,\n onMissingQualifiedSymbol,\n strictTemplateParamArgLists=False,\n ancestorLookupType=typ,\n templateShorthand=templateShorthand,\n matchSelf=matchSelf,\n recurseInAnon=recurseInAnon,\n correctPrimaryTemplateArgs=False,\n searchInSiblings=False)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n if lookupResult is None:\n return None\n\n symbols = list(lookupResult.symbols)\n if len(symbols) == 0:\n return None\n\n querySymbol = Symbol(parent=lookupResult.parentSymbol,\n identOrOp=lookupResult.identOrOp,\n templateParams=lookupResult.templateParams,\n templateArgs=lookupResult.templateArgs,\n declaration=declaration,\n docname='fakeDocnameForQuery')\n queryId = declaration.get_newest_id()\n for symbol in symbols:\n if symbol.declaration is None:\n continue\n candId = symbol.declaration.get_newest_id()\n if candId == queryId:\n querySymbol.remove()\n return symbol\n querySymbol.remove()\n return None\n\n def to_string(self, indent: int) -> str:\n res = [Symbol.debug_indent_string * indent]\n if not self.parent:\n res.append('::')\n else:\n if self.templateParams:\n res.append(str(self.templateParams))\n res.append('\\n')\n res.append(Symbol.debug_indent_string * indent)\n if self.identOrOp:\n res.append(str(self.identOrOp))\n else:\n res.append(str(self.declaration))\n if self.templateArgs:\n res.append(str(self.templateArgs))\n if self.declaration:\n res.append(\": \")\n if self.isRedeclaration:\n res.append('!!duplicate!! ')\n res.append(str(self.declaration))\n if self.docname:\n res.append('\\t(')\n res.append(self.docname)\n res.append(')')\n res.append('\\n')\n return ''.join(res)\n\n def dump(self, indent: int) -> str:\n res = [self.to_string(indent)]\n for c in self._children:\n res.append(c.dump(indent + 1))\n return ''.join(res)\n\n\nclass DefinitionParser(BaseParser):\n # those without signedness and size modifiers\n # see https://en.cppreference.com/w/cpp/language/types\n _simple_fundemental_types = (\n 'void', 'bool', 'char', 'wchar_t', 'char16_t', 'char32_t', 'int',\n 'float', 'double', 'auto'\n )\n\n _prefix_keys = ('class', 'struct', 'enum', 'union', 'typename')\n\n @property\n def language(self) -> str:\n return 'C++'\n\n @property\n def id_attributes(self):\n return self.config.cpp_id_attributes\n\n @property\n def paren_attributes(self):\n return self.config.cpp_paren_attributes\n\n def _parse_string(self) -> str:\n if self.current_char != '\"':\n return None\n startPos = self.pos\n self.pos += 1\n escape = False\n while True:\n if self.eof:\n self.fail(\"Unexpected end during inside string.\")\n elif self.current_char == '\"' and not escape:\n self.pos += 1\n break\n elif self.current_char == '\\\\':\n escape = True\n else:\n escape = False\n self.pos += 1\n return self.definition[startPos:self.pos]\n\n def _parse_literal(self) -> ASTLiteral:\n # -> integer-literal\n # | character-literal\n # | floating-literal\n # | string-literal\n # | boolean-literal -> \"false\" | \"true\"\n # | pointer-literal -> \"nullptr\"\n # | user-defined-literal\n self.skip_ws()\n if self.skip_word('nullptr'):\n return ASTPointerLiteral()\n if self.skip_word('true'):\n return ASTBooleanLiteral(True)\n if self.skip_word('false'):\n return ASTBooleanLiteral(False)\n for regex in [float_literal_re, binary_literal_re, hex_literal_re,\n integer_literal_re, octal_literal_re]:\n pos = self.pos\n if self.match(regex):\n while self.current_char in 'uUlLfF':\n self.pos += 1\n return ASTNumberLiteral(self.definition[pos:self.pos])\n\n string = self._parse_string()\n if string is not None:\n return ASTStringLiteral(string)\n\n # character-literal\n if self.match(char_literal_re):\n prefix = self.last_match.group(1) # may be None when no prefix\n data = self.last_match.group(2)\n try:\n return ASTCharLiteral(prefix, data)\n except UnicodeDecodeError as e:\n self.fail(\"Can not handle character literal. Internal error was: %s\" % e)\n except UnsupportedMultiCharacterCharLiteral:\n self.fail(\"Can not handle character literal\"\n \" resulting in multiple decoded characters.\")\n\n # TODO: user-defined lit\n return None\n\n def _parse_fold_or_paren_expression(self) -> ASTExpression:\n # \"(\" expression \")\"\n # fold-expression\n # -> ( cast-expression fold-operator ... )\n # | ( ... fold-operator cast-expression )\n # | ( cast-expression fold-operator ... fold-operator cast-expression\n if self.current_char != '(':\n return None\n self.pos += 1\n self.skip_ws()\n if self.skip_string_and_ws(\"...\"):\n # ( ... fold-operator cast-expression )\n if not self.match(_fold_operator_re):\n self.fail(\"Expected fold operator after '...' in fold expression.\")\n op = self.matched_text\n rightExpr = self._parse_cast_expression()\n if not self.skip_string(')'):\n self.fail(\"Expected ')' in end of fold expression.\")\n return ASTFoldExpr(None, op, rightExpr)\n # try first parsing a unary right fold, or a binary fold\n pos = self.pos\n try:\n self.skip_ws()\n leftExpr = self._parse_cast_expression()\n self.skip_ws()\n if not self.match(_fold_operator_re):\n self.fail(\"Expected fold operator after left expression in fold expression.\")\n op = self.matched_text\n self.skip_ws()\n if not self.skip_string_and_ws('...'):\n self.fail(\"Expected '...' after fold operator in fold expression.\")\n except DefinitionError as eFold:\n self.pos = pos\n # fall back to a paren expression\n try:\n res = self._parse_expression()\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expected ')' in end of parenthesized expression.\")\n except DefinitionError as eExpr:\n raise self._make_multi_error([\n (eFold, \"If fold expression\"),\n (eExpr, \"If parenthesized expression\")\n ], \"Error in fold expression or parenthesized expression.\")\n return ASTParenExpr(res)\n # now it definitely is a fold expression\n if self.skip_string(')'):\n return ASTFoldExpr(leftExpr, op, None)\n if not self.match(_fold_operator_re):\n self.fail(\"Expected fold operator or ')' after '...' in fold expression.\")\n if op != self.matched_text:\n self.fail(\"Operators are different in binary fold: '%s' and '%s'.\"\n % (op, self.matched_text))\n rightExpr = self._parse_cast_expression()\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expected ')' to end binary fold expression.\")\n return ASTFoldExpr(leftExpr, op, rightExpr)\n\n def _parse_primary_expression(self) -> ASTExpression:\n # literal\n # \"this\"\n # lambda-expression\n # \"(\" expression \")\"\n # fold-expression\n # id-expression -> we parse this with _parse_nested_name\n self.skip_ws()\n res = self._parse_literal() # type: ASTExpression\n if res is not None:\n return res\n self.skip_ws()\n if self.skip_word(\"this\"):\n return ASTThisLiteral()\n # TODO: try lambda expression\n res = self._parse_fold_or_paren_expression()\n if res is not None:\n return res\n nn = self._parse_nested_name()\n if nn is not None:\n return ASTIdExpression(nn)\n return None\n\n def _parse_initializer_list(self, name: str, open: str, close: str\n ) -> Tuple[List[Union[ASTExpression,\n ASTBracedInitList]],\n bool]:\n # Parse open and close with the actual initializer-list inbetween\n # -> initializer-clause '...'[opt]\n # | initializer-list ',' initializer-clause '...'[opt]\n self.skip_ws()\n if not self.skip_string_and_ws(open):\n return None, None\n if self.skip_string(close):\n return [], False\n\n exprs = [] # type: List[Union[ASTExpression, ASTBracedInitList]]\n trailingComma = False\n while True:\n self.skip_ws()\n expr = self._parse_initializer_clause()\n self.skip_ws()\n if self.skip_string('...'):\n exprs.append(ASTPackExpansionExpr(expr))\n else:\n exprs.append(expr)\n self.skip_ws()\n if self.skip_string(close):\n break\n if not self.skip_string_and_ws(','):\n self.fail(\"Error in %s, expected ',' or '%s'.\" % (name, close))\n if self.current_char == close and close == '}':\n self.pos += 1\n trailingComma = True\n break\n return exprs, trailingComma\n\n def _parse_paren_expression_list(self) -> ASTParenExprList:\n # -> '(' expression-list ')'\n # though, we relax it to also allow empty parens\n # as it's needed in some cases\n #\n # expression-list\n # -> initializer-list\n exprs, trailingComma = self._parse_initializer_list(\"parenthesized expression-list\",\n '(', ')')\n if exprs is None:\n return None\n return ASTParenExprList(exprs)\n\n def _parse_initializer_clause(self) -> Union[ASTExpression, ASTBracedInitList]:\n bracedInitList = self._parse_braced_init_list()\n if bracedInitList is not None:\n return bracedInitList\n return self._parse_assignment_expression(inTemplate=False)\n\n def _parse_braced_init_list(self) -> ASTBracedInitList:\n # -> '{' initializer-list ','[opt] '}'\n # | '{' '}'\n exprs, trailingComma = self._parse_initializer_list(\"braced-init-list\", '{', '}')\n if exprs is None:\n return None\n return ASTBracedInitList(exprs, trailingComma)\n\n def _parse_expression_list_or_braced_init_list(\n self\n ) -> Union[ASTParenExprList, ASTBracedInitList]:\n paren = self._parse_paren_expression_list()\n if paren is not None:\n return paren\n return self._parse_braced_init_list()\n\n def _parse_postfix_expression(self) -> ASTPostfixExpr:\n # -> primary\n # | postfix \"[\" expression \"]\"\n # | postfix \"[\" braced-init-list [opt] \"]\"\n # | postfix \"(\" expression-list [opt] \")\"\n # | postfix \".\" \"template\" [opt] id-expression\n # | postfix \"->\" \"template\" [opt] id-expression\n # | postfix \".\" pseudo-destructor-name\n # | postfix \"->\" pseudo-destructor-name\n # | postfix \"++\"\n # | postfix \"--\"\n # | simple-type-specifier \"(\" expression-list [opt] \")\"\n # | simple-type-specifier braced-init-list\n # | typename-specifier \"(\" expression-list [opt] \")\"\n # | typename-specifier braced-init-list\n # | \"dynamic_cast\" \"<\" type-id \">\" \"(\" expression \")\"\n # | \"static_cast\" \"<\" type-id \">\" \"(\" expression \")\"\n # | \"reinterpret_cast\" \"<\" type-id \">\" \"(\" expression \")\"\n # | \"const_cast\" \"<\" type-id \">\" \"(\" expression \")\"\n # | \"typeid\" \"(\" expression \")\"\n # | \"typeid\" \"(\" type-id \")\"\n\n prefixType = None\n prefix = None # type: Any\n self.skip_ws()\n\n cast = None\n for c in _id_explicit_cast:\n if self.skip_word_and_ws(c):\n cast = c\n break\n if cast is not None:\n prefixType = \"cast\"\n if not self.skip_string(\"<\"):\n self.fail(\"Expected '<' afer '%s'.\" % cast)\n typ = self._parse_type(False)\n self.skip_ws()\n if not self.skip_string_and_ws(\">\"):\n self.fail(\"Expected '>' after type in '%s'.\" % cast)\n if not self.skip_string(\"(\"):\n self.fail(\"Expected '(' in '%s'.\" % cast)\n\n def parser() -> ASTExpression:\n return self._parse_expression()\n expr = self._parse_expression_fallback([')'], parser)\n self.skip_ws()\n if not self.skip_string(\")\"):\n self.fail(\"Expected ')' to end '%s'.\" % cast)\n prefix = ASTExplicitCast(cast, typ, expr)\n elif self.skip_word_and_ws(\"typeid\"):\n prefixType = \"typeid\"\n if not self.skip_string_and_ws('('):\n self.fail(\"Expected '(' after 'typeid'.\")\n pos = self.pos\n try:\n typ = self._parse_type(False)\n prefix = ASTTypeId(typ, isType=True)\n if not self.skip_string(')'):\n self.fail(\"Expected ')' to end 'typeid' of type.\")\n except DefinitionError as eType:\n self.pos = pos\n try:\n\n def parser() -> ASTExpression:\n return self._parse_expression()\n expr = self._parse_expression_fallback([')'], parser)\n prefix = ASTTypeId(expr, isType=False)\n if not self.skip_string(')'):\n self.fail(\"Expected ')' to end 'typeid' of expression.\")\n except DefinitionError as eExpr:\n self.pos = pos\n header = \"Error in 'typeid(...)'.\"\n header += \" Expected type or expression.\"\n errors = []\n errors.append((eType, \"If type\"))\n errors.append((eExpr, \"If expression\"))\n raise self._make_multi_error(errors, header)\n else: # a primary expression or a type\n pos = self.pos\n try:\n prefix = self._parse_primary_expression()\n prefixType = 'expr'\n except DefinitionError as eOuter:\n self.pos = pos\n try:\n # we are potentially casting, so save parens for us\n # TODO: hmm, would we need to try both with operatorCast and with None?\n prefix = self._parse_type(False, 'operatorCast')\n prefixType = 'typeOperatorCast'\n # | simple-type-specifier \"(\" expression-list [opt] \")\"\n # | simple-type-specifier braced-init-list\n # | typename-specifier \"(\" expression-list [opt] \")\"\n # | typename-specifier braced-init-list\n self.skip_ws()\n if self.current_char != '(' and self.current_char != '{':\n self.fail(\"Expecting '(' or '{' after type in cast expression.\")\n except DefinitionError as eInner:\n self.pos = pos\n header = \"Error in postfix expression,\"\n header += \" expected primary expression or type.\"\n errors = []\n errors.append((eOuter, \"If primary expression\"))\n errors.append((eInner, \"If type\"))\n raise self._make_multi_error(errors, header)\n\n # and now parse postfixes\n postFixes = [] # type: List[ASTPostfixOp]\n while True:\n self.skip_ws()\n if prefixType in ['expr', 'cast', 'typeid']:\n if self.skip_string_and_ws('['):\n expr = self._parse_expression()\n self.skip_ws()\n if not self.skip_string(']'):\n self.fail(\"Expected ']' in end of postfix expression.\")\n postFixes.append(ASTPostfixArray(expr))\n continue\n if self.skip_string('.'):\n if self.skip_string('*'):\n # don't steal the dot\n self.pos -= 2\n elif self.skip_string('..'):\n # don't steal the dot\n self.pos -= 3\n else:\n name = self._parse_nested_name()\n postFixes.append(ASTPostfixMember(name))\n continue\n if self.skip_string('->'):\n if self.skip_string('*'):\n # don't steal the arrow\n self.pos -= 3\n else:\n name = self._parse_nested_name()\n postFixes.append(ASTPostfixMemberOfPointer(name))\n continue\n if self.skip_string('++'):\n postFixes.append(ASTPostfixInc())\n continue\n if self.skip_string('--'):\n postFixes.append(ASTPostfixDec())\n continue\n lst = self._parse_expression_list_or_braced_init_list()\n if lst is not None:\n postFixes.append(ASTPostfixCallExpr(lst))\n continue\n break\n return ASTPostfixExpr(prefix, postFixes)\n\n def _parse_unary_expression(self) -> ASTExpression:\n # -> postfix\n # | \"++\" cast\n # | \"--\" cast\n # | unary-operator cast -> (* | & | + | - | ! | ~) cast\n # The rest:\n # | \"sizeof\" unary\n # | \"sizeof\" \"(\" type-id \")\"\n # | \"sizeof\" \"...\" \"(\" identifier \")\"\n # | \"alignof\" \"(\" type-id \")\"\n # | noexcept-expression -> noexcept \"(\" expression \")\"\n # | new-expression\n # | delete-expression\n self.skip_ws()\n for op in _expression_unary_ops:\n # TODO: hmm, should we be able to backtrack here?\n if op[0] in 'cn':\n res = self.skip_word(op)\n else:\n res = self.skip_string(op)\n if res:\n expr = self._parse_cast_expression()\n return ASTUnaryOpExpr(op, expr)\n if self.skip_word_and_ws('sizeof'):\n if self.skip_string_and_ws('...'):\n if not self.skip_string_and_ws('('):\n self.fail(\"Expecting '(' after 'sizeof...'.\")\n if not self.match(identifier_re):\n self.fail(\"Expecting identifier for 'sizeof...'.\")\n ident = ASTIdentifier(self.matched_text)\n self.skip_ws()\n if not self.skip_string(\")\"):\n self.fail(\"Expecting ')' to end 'sizeof...'.\")\n return ASTSizeofParamPack(ident)\n if self.skip_string_and_ws('('):\n typ = self._parse_type(named=False)\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expecting ')' to end 'sizeof'.\")\n return ASTSizeofType(typ)\n expr = self._parse_unary_expression()\n return ASTSizeofExpr(expr)\n if self.skip_word_and_ws('alignof'):\n if not self.skip_string_and_ws('('):\n self.fail(\"Expecting '(' after 'alignof'.\")\n typ = self._parse_type(named=False)\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expecting ')' to end 'alignof'.\")\n return ASTAlignofExpr(typ)\n if self.skip_word_and_ws('noexcept'):\n if not self.skip_string_and_ws('('):\n self.fail(\"Expecting '(' after 'noexcept'.\")\n expr = self._parse_expression()\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expecting ')' to end 'noexcept'.\")\n return ASTNoexceptExpr(expr)\n # new-expression\n pos = self.pos\n rooted = self.skip_string('::')\n self.skip_ws()\n if not self.skip_word_and_ws('new'):\n self.pos = pos\n else:\n # new-placement[opt] new-type-id new-initializer[opt]\n # new-placement[opt] ( type-id ) new-initializer[opt]\n isNewTypeId = True\n if self.skip_string_and_ws('('):\n # either this is a new-placement or it's the second production\n # without placement, and it's actually the ( type-id ) part\n self.fail(\"Sorry, neither new-placement nor parenthesised type-id \"\n \"in new-epression is supported yet.\")\n # set isNewTypeId = False if it's (type-id)\n if isNewTypeId:\n declSpecs = self._parse_decl_specs(outer=None)\n decl = self._parse_declarator(named=False, paramMode=\"new\")\n else:\n self.fail(\"Sorry, parenthesised type-id in new expression not yet supported.\")\n lst = self._parse_expression_list_or_braced_init_list()\n return ASTNewExpr(rooted, isNewTypeId, ASTType(declSpecs, decl), lst)\n # delete-expression\n pos = self.pos\n rooted = self.skip_string('::')\n self.skip_ws()\n if not self.skip_word_and_ws('delete'):\n self.pos = pos\n else:\n array = self.skip_string_and_ws('[')\n if array and not self.skip_string_and_ws(']'):\n self.fail(\"Expected ']' in array delete-expression.\")\n expr = self._parse_cast_expression()\n return ASTDeleteExpr(rooted, array, expr)\n return self._parse_postfix_expression()\n\n def _parse_cast_expression(self) -> ASTExpression:\n # -> unary | \"(\" type-id \")\" cast\n pos = self.pos\n self.skip_ws()\n if self.skip_string('('):\n try:\n typ = self._parse_type(False)\n if not self.skip_string(')'):\n self.fail(\"Expected ')' in cast expression.\")\n expr = self._parse_cast_expression()\n return ASTCastExpr(typ, expr)\n except DefinitionError as exCast:\n self.pos = pos\n try:\n return self._parse_unary_expression()\n except DefinitionError as exUnary:\n errs = []\n errs.append((exCast, \"If type cast expression\"))\n errs.append((exUnary, \"If unary expression\"))\n raise self._make_multi_error(errs, \"Error in cast expression.\")\n else:\n return self._parse_unary_expression()\n\n def _parse_logical_or_expression(self, inTemplate: bool) -> ASTExpression:\n # logical-or = logical-and ||\n # logical-and = inclusive-or &&\n # inclusive-or = exclusive-or |\n # exclusive-or = and ^\n # and = equality &\n # equality = relational ==, !=\n # relational = shift <, >, <=, >=\n # shift = additive <<, >>\n # additive = multiplicative +, -\n # multiplicative = pm *, /, %\n # pm = cast .*, ->*\n def _parse_bin_op_expr(self: DefinitionParser,\n opId: int, inTemplate: bool) -> ASTExpression:\n if opId + 1 == len(_expression_bin_ops):\n def parser(inTemplate: bool) -> ASTExpression:\n return self._parse_cast_expression()\n else:\n def parser(inTemplate: bool) -> ASTExpression:\n return _parse_bin_op_expr(self, opId + 1, inTemplate=inTemplate)\n exprs = []\n ops = []\n exprs.append(parser(inTemplate=inTemplate))\n while True:\n self.skip_ws()\n if inTemplate and self.current_char == '>':\n break\n pos = self.pos\n oneMore = False\n for op in _expression_bin_ops[opId]:\n if op[0] in 'abcnox':\n if not self.skip_word(op):\n continue\n else:\n if not self.skip_string(op):\n continue\n if op == '&' and self.current_char == '&':\n # don't split the && 'token'\n self.pos -= 1\n # and btw. && has lower precedence, so we are done\n break\n try:\n expr = parser(inTemplate=inTemplate)\n exprs.append(expr)\n ops.append(op)\n oneMore = True\n break\n except DefinitionError:\n self.pos = pos\n if not oneMore:\n break\n return ASTBinOpExpr(exprs, ops)\n return _parse_bin_op_expr(self, 0, inTemplate=inTemplate)\n\n def _parse_conditional_expression_tail(self, orExprHead: Any) -> None:\n # -> \"?\" expression \":\" assignment-expression\n return None\n\n def _parse_assignment_expression(self, inTemplate: bool) -> ASTExpression:\n # -> conditional-expression\n # | logical-or-expression assignment-operator initializer-clause\n # | throw-expression\n # TODO: parse throw-expression: \"throw\" assignment-expression [opt]\n # if not a throw expression, then:\n # -> conditional-expression ->\n # logical-or-expression\n # | logical-or-expression \"?\" expression \":\" assignment-expression\n # | logical-or-expression assignment-operator initializer-clause\n exprs = [] # type: List[Union[ASTExpression, ASTBracedInitList]]\n ops = []\n orExpr = self._parse_logical_or_expression(inTemplate=inTemplate)\n exprs.append(orExpr)\n # TODO: handle ternary with _parse_conditional_expression_tail\n while True:\n oneMore = False\n self.skip_ws()\n for op in _expression_assignment_ops:\n if op[0] in 'anox':\n if not self.skip_word(op):\n continue\n else:\n if not self.skip_string(op):\n continue\n expr = self._parse_initializer_clause()\n exprs.append(expr)\n ops.append(op)\n oneMore = True\n if not oneMore:\n break\n if len(ops) == 0:\n return orExpr\n else:\n return ASTAssignmentExpr(exprs, ops)\n\n def _parse_constant_expression(self, inTemplate: bool) -> ASTExpression:\n # -> conditional-expression\n orExpr = self._parse_logical_or_expression(inTemplate=inTemplate)\n # TODO: use _parse_conditional_expression_tail\n return orExpr\n\n def _parse_expression(self) -> ASTExpression:\n # -> assignment-expression\n # | expression \",\" assignment-expresion\n exprs = [self._parse_assignment_expression(inTemplate=False)]\n while True:\n self.skip_ws()\n if not self.skip_string(','):\n break\n exprs.append(self._parse_assignment_expression(inTemplate=False))\n if len(exprs) == 1:\n return exprs[0]\n else:\n return ASTCommaExpr(exprs)\n\n def _parse_expression_fallback(self, end: List[str],\n parser: Callable[[], ASTExpression],\n allow: bool = True) -> ASTExpression:\n # Stupidly \"parse\" an expression.\n # 'end' should be a list of characters which ends the expression.\n\n # first try to use the provided parser\n prevPos = self.pos\n try:\n return parser()\n except DefinitionError as e:\n # some places (e.g., template parameters) we really don't want to use fallback,\n # and for testing we may want to globally disable it\n if not allow or not self.allowFallbackExpressionParsing:\n raise\n self.warn(\"Parsing of expression failed. Using fallback parser.\"\n \" Error was:\\n%s\" % e)\n self.pos = prevPos\n # and then the fallback scanning\n assert end is not None\n self.skip_ws()\n startPos = self.pos\n if self.match(_string_re):\n value = self.matched_text\n else:\n # TODO: add handling of more bracket-like things, and quote handling\n brackets = {'(': ')', '{': '}', '[': ']', '<': '>'}\n symbols = [] # type: List[str]\n while not self.eof:\n if (len(symbols) == 0 and self.current_char in end):\n break\n if self.current_char in brackets.keys():\n symbols.append(brackets[self.current_char])\n elif len(symbols) > 0 and self.current_char == symbols[-1]:\n symbols.pop()\n self.pos += 1\n if len(end) > 0 and self.eof:\n self.fail(\"Could not find end of expression starting at %d.\"\n % startPos)\n value = self.definition[startPos:self.pos].strip()\n return ASTFallbackExpr(value.strip())\n\n # ==========================================================================\n\n def _parse_operator(self) -> ASTOperator:\n self.skip_ws()\n # adapted from the old code\n # yay, a regular operator definition\n if self.match(_operator_re):\n return ASTOperatorBuildIn(self.matched_text)\n\n # new/delete operator?\n for op in 'new', 'delete':\n if not self.skip_word(op):\n continue\n self.skip_ws()\n if self.skip_string('['):\n self.skip_ws()\n if not self.skip_string(']'):\n self.fail('Expected \"]\" after \"operator ' + op + '[\"')\n op += '[]'\n return ASTOperatorBuildIn(op)\n\n # user-defined literal?\n if self.skip_string('\"\"'):\n self.skip_ws()\n if not self.match(identifier_re):\n self.fail(\"Expected user-defined literal suffix.\")\n identifier = ASTIdentifier(self.matched_text)\n return ASTOperatorLiteral(identifier)\n\n # oh well, looks like a cast operator definition.\n # In that case, eat another type.\n type = self._parse_type(named=False, outer=\"operatorCast\")\n return ASTOperatorType(type)\n\n def _parse_template_argument_list(self) -> ASTTemplateArgs:\n # template-argument-list: (but we include the < and > here\n # template-argument ...[opt]\n # template-argument-list, template-argument ...[opt]\n # template-argument:\n # constant-expression\n # type-id\n # id-expression\n self.skip_ws()\n if not self.skip_string_and_ws('<'):\n return None\n if self.skip_string('>'):\n return ASTTemplateArgs([], False)\n prevErrors = []\n templateArgs = [] # type: List[Union[ASTType, ASTTemplateArgConstant]]\n packExpansion = False\n while 1:\n pos = self.pos\n parsedComma = False\n parsedEnd = False\n try:\n type = self._parse_type(named=False)\n self.skip_ws()\n if self.skip_string_and_ws('...'):\n packExpansion = True\n parsedEnd = True\n if not self.skip_string('>'):\n self.fail('Expected \">\" after \"...\" in template argument list.')\n elif self.skip_string('>'):\n parsedEnd = True\n elif self.skip_string(','):\n parsedComma = True\n else:\n self.fail('Expected \"...>\", \">\" or \",\" in template argument list.')\n templateArgs.append(type)\n except DefinitionError as e:\n prevErrors.append((e, \"If type argument\"))\n self.pos = pos\n try:\n value = self._parse_constant_expression(inTemplate=True)\n self.skip_ws()\n if self.skip_string_and_ws('...'):\n packExpansion = True\n parsedEnd = True\n if not self.skip_string('>'):\n self.fail('Expected \">\" after \"...\" in template argument list.')\n elif self.skip_string('>'):\n parsedEnd = True\n elif self.skip_string(','):\n parsedComma = True\n else:\n self.fail('Expected \"...>\", \">\" or \",\" in template argument list.')\n templateArgs.append(ASTTemplateArgConstant(value))\n except DefinitionError as e:\n self.pos = pos\n prevErrors.append((e, \"If non-type argument\"))\n header = \"Error in parsing template argument list.\"\n raise self._make_multi_error(prevErrors, header)\n if parsedEnd:\n assert not parsedComma\n break\n else:\n assert not packExpansion\n return ASTTemplateArgs(templateArgs, packExpansion)\n\n def _parse_nested_name(self, memberPointer: bool = False) -> ASTNestedName:\n names = [] # type: List[ASTNestedNameElement]\n templates = [] # type: List[bool]\n\n self.skip_ws()\n rooted = False\n if self.skip_string('::'):\n rooted = True\n while 1:\n self.skip_ws()\n if len(names) > 0:\n template = self.skip_word_and_ws('template')\n else:\n template = False\n templates.append(template)\n identOrOp = None # type: Union[ASTIdentifier, ASTOperator]\n if self.skip_word_and_ws('operator'):\n identOrOp = self._parse_operator()\n else:\n if not self.match(identifier_re):\n if memberPointer and len(names) > 0:\n templates.pop()\n break\n self.fail(\"Expected identifier in nested name.\")\n identifier = self.matched_text\n # make sure there isn't a keyword\n if identifier in _keywords:\n self.fail(\"Expected identifier in nested name, \"\n \"got keyword: %s\" % identifier)\n identOrOp = ASTIdentifier(identifier)\n # try greedily to get template arguments,\n # but otherwise a < might be because we are in an expression\n pos = self.pos\n try:\n templateArgs = self._parse_template_argument_list()\n except DefinitionError as ex:\n self.pos = pos\n templateArgs = None\n self.otherErrors.append(ex)\n names.append(ASTNestedNameElement(identOrOp, templateArgs))\n\n self.skip_ws()\n if not self.skip_string('::'):\n if memberPointer:\n self.fail(\"Expected '::' in pointer to member (function).\")\n break\n return ASTNestedName(names, templates, rooted)\n\n # ==========================================================================\n\n def _parse_trailing_type_spec(self) -> ASTTrailingTypeSpec:\n # fundemental types\n self.skip_ws()\n for t in self._simple_fundemental_types:\n if self.skip_word(t):\n return ASTTrailingTypeSpecFundamental(t)\n\n # TODO: this could/should be more strict\n elements = []\n if self.skip_word_and_ws('signed'):\n elements.append('signed')\n elif self.skip_word_and_ws('unsigned'):\n elements.append('unsigned')\n while 1:\n if self.skip_word_and_ws('short'):\n elements.append('short')\n elif self.skip_word_and_ws('long'):\n elements.append('long')\n else:\n break\n if self.skip_word_and_ws('char'):\n elements.append('char')\n elif self.skip_word_and_ws('int'):\n elements.append('int')\n elif self.skip_word_and_ws('double'):\n elements.append('double')\n if len(elements) > 0:\n return ASTTrailingTypeSpecFundamental(' '.join(elements))\n\n # decltype\n self.skip_ws()\n if self.skip_word_and_ws('decltype'):\n if not self.skip_string_and_ws('('):\n self.fail(\"Expected '(' after 'decltype'.\")\n if self.skip_word_and_ws('auto'):\n if not self.skip_string(')'):\n self.fail(\"Expected ')' after 'decltype(auto'.\")\n return ASTTrailingTypeSpecDecltypeAuto()\n expr = self._parse_expression()\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expected ')' after 'decltype(<expr>'.\")\n return ASTTrailingTypeSpecDecltype(expr)\n\n # prefixed\n prefix = None\n self.skip_ws()\n for k in self._prefix_keys:\n if self.skip_word_and_ws(k):\n prefix = k\n break\n nestedName = self._parse_nested_name()\n return ASTTrailingTypeSpecName(prefix, nestedName)\n\n def _parse_parameters_and_qualifiers(self, paramMode: str) -> ASTParametersQualifiers:\n if paramMode == 'new':\n return None\n self.skip_ws()\n if not self.skip_string('('):\n if paramMode == 'function':\n self.fail('Expecting \"(\" in parameters-and-qualifiers.')\n else:\n return None\n args = []\n self.skip_ws()\n if not self.skip_string(')'):\n while 1:\n self.skip_ws()\n if self.skip_string('...'):\n args.append(ASTFunctionParameter(None, True))\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail('Expected \")\" after \"...\" in '\n 'parameters-and-qualifiers.')\n break\n # note: it seems that function arguments can always be named,\n # even in function pointers and similar.\n arg = self._parse_type_with_init(outer=None, named='single')\n # TODO: parse default parameters # TODO: didn't we just do that?\n args.append(ASTFunctionParameter(arg))\n\n self.skip_ws()\n if self.skip_string(','):\n continue\n elif self.skip_string(')'):\n break\n else:\n self.fail(\n 'Expecting \",\" or \")\" in parameters-and-qualifiers, '\n 'got \"%s\".' % self.current_char)\n\n # TODO: why did we have this bail-out?\n # does it hurt to parse the extra stuff?\n # it's needed for pointer to member functions\n if paramMode != 'function' and False:\n return ASTParametersQualifiers(\n args, None, None, None, None, None, None, None)\n\n self.skip_ws()\n const = self.skip_word_and_ws('const')\n volatile = self.skip_word_and_ws('volatile')\n if not const: # the can be permuted\n const = self.skip_word_and_ws('const')\n\n refQual = None\n if self.skip_string('&&'):\n refQual = '&&'\n if not refQual and self.skip_string('&'):\n refQual = '&'\n\n exceptionSpec = None\n override = None\n final = None\n initializer = None\n self.skip_ws()\n if self.skip_string('noexcept'):\n exceptionSpec = 'noexcept'\n self.skip_ws()\n if self.skip_string('('):\n self.fail('Parameterised \"noexcept\" not yet implemented.')\n\n self.skip_ws()\n override = self.skip_word_and_ws('override')\n final = self.skip_word_and_ws('final')\n if not override:\n override = self.skip_word_and_ws(\n 'override') # they can be permuted\n\n self.skip_ws()\n if self.skip_string('='):\n self.skip_ws()\n valid = ('0', 'delete', 'default')\n for w in valid:\n if self.skip_word_and_ws(w):\n initializer = w\n break\n if not initializer:\n self.fail(\n 'Expected \"%s\" in initializer-specifier.'\n % '\" or \"'.join(valid))\n\n return ASTParametersQualifiers(\n args, volatile, const, refQual, exceptionSpec, override, final,\n initializer)\n\n def _parse_decl_specs_simple(self, outer: str, typed: bool) -> ASTDeclSpecsSimple:\n \"\"\"Just parse the simple ones.\"\"\"\n storage = None\n threadLocal = None\n inline = None\n virtual = None\n explicit = None\n constexpr = None\n volatile = None\n const = None\n friend = None\n attrs = []\n while 1: # accept any permutation of a subset of some decl-specs\n self.skip_ws()\n if not storage:\n if outer in ('member', 'function'):\n if self.skip_word('static'):\n storage = 'static'\n continue\n if self.skip_word('extern'):\n storage = 'extern'\n continue\n if outer == 'member':\n if self.skip_word('mutable'):\n storage = 'mutable'\n continue\n if self.skip_word('register'):\n storage = 'register'\n continue\n if not threadLocal and outer == 'member':\n threadLocal = self.skip_word('thread_local')\n if threadLocal:\n continue\n\n if outer == 'function':\n # function-specifiers\n if not inline:\n inline = self.skip_word('inline')\n if inline:\n continue\n if not friend:\n friend = self.skip_word('friend')\n if friend:\n continue\n if not virtual:\n virtual = self.skip_word('virtual')\n if virtual:\n continue\n if not explicit:\n explicit = self.skip_word('explicit')\n if explicit:\n continue\n\n if not constexpr and outer in ('member', 'function'):\n constexpr = self.skip_word(\"constexpr\")\n if constexpr:\n continue\n if not volatile and typed:\n volatile = self.skip_word('volatile')\n if volatile:\n continue\n if not const and typed:\n const = self.skip_word('const')\n if const:\n continue\n attr = self._parse_attribute()\n if attr:\n attrs.append(attr)\n continue\n break\n return ASTDeclSpecsSimple(storage, threadLocal, inline, virtual,\n explicit, constexpr, volatile, const,\n friend, attrs)\n\n def _parse_decl_specs(self, outer: str, typed: bool = True) -> ASTDeclSpecs:\n if outer:\n if outer not in ('type', 'member', 'function', 'templateParam'):\n raise Exception('Internal error, unknown outer \"%s\".' % outer)\n \"\"\"\n storage-class-specifier function-specifier \"constexpr\"\n \"volatile\" \"const\" trailing-type-specifier\n\n storage-class-specifier ->\n \"static\" (only for member_object and function_object)\n | \"register\"\n\n function-specifier -> \"inline\" | \"virtual\" | \"explicit\" (only for\n function_object)\n\n \"constexpr\" (only for member_object and function_object)\n \"\"\"\n leftSpecs = self._parse_decl_specs_simple(outer, typed)\n rightSpecs = None\n\n if typed:\n trailing = self._parse_trailing_type_spec()\n rightSpecs = self._parse_decl_specs_simple(outer, typed)\n else:\n trailing = None\n return ASTDeclSpecs(outer, leftSpecs, rightSpecs, trailing)\n\n def _parse_declarator_name_suffix(\n self, named: Union[bool, str], paramMode: str, typed: bool\n ) -> Union[ASTDeclaratorNameParamQual, ASTDeclaratorNameBitField]:\n # now we should parse the name, and then suffixes\n if named == 'maybe':\n pos = self.pos\n try:\n declId = self._parse_nested_name()\n except DefinitionError:\n self.pos = pos\n declId = None\n elif named == 'single':\n if self.match(identifier_re):\n identifier = ASTIdentifier(self.matched_text)\n nne = ASTNestedNameElement(identifier, None)\n declId = ASTNestedName([nne], [False], rooted=False)\n # if it's a member pointer, we may have '::', which should be an error\n self.skip_ws()\n if self.current_char == ':':\n self.fail(\"Unexpected ':' after identifier.\")\n else:\n declId = None\n elif named:\n declId = self._parse_nested_name()\n else:\n declId = None\n arrayOps = []\n while 1:\n self.skip_ws()\n if typed and self.skip_string('['):\n self.skip_ws()\n if self.skip_string(']'):\n arrayOps.append(ASTArray(None))\n continue\n\n def parser() -> ASTExpression:\n return self._parse_expression()\n value = self._parse_expression_fallback([']'], parser)\n if not self.skip_string(']'):\n self.fail(\"Expected ']' in end of array operator.\")\n arrayOps.append(ASTArray(value))\n continue\n else:\n break\n paramQual = self._parse_parameters_and_qualifiers(paramMode)\n if paramQual is None and len(arrayOps) == 0:\n # perhaps a bit-field\n if named and paramMode == 'type' and typed:\n self.skip_ws()\n if self.skip_string(':'):\n size = self._parse_constant_expression(inTemplate=False)\n return ASTDeclaratorNameBitField(declId=declId, size=size)\n return ASTDeclaratorNameParamQual(declId=declId, arrayOps=arrayOps,\n paramQual=paramQual)\n\n def _parse_declarator(self, named: Union[bool, str], paramMode: str,\n typed: bool = True\n ) -> ASTDeclarator:\n # 'typed' here means 'parse return type stuff'\n if paramMode not in ('type', 'function', 'operatorCast', 'new'):\n raise Exception(\n \"Internal error, unknown paramMode '%s'.\" % paramMode)\n prevErrors = []\n self.skip_ws()\n if typed and self.skip_string('*'):\n self.skip_ws()\n volatile = False\n const = False\n attrs = []\n while 1:\n if not volatile:\n volatile = self.skip_word_and_ws('volatile')\n if volatile:\n continue\n if not const:\n const = self.skip_word_and_ws('const')\n if const:\n continue\n attr = self._parse_attribute()\n if attr is not None:\n attrs.append(attr)\n continue\n break\n next = self._parse_declarator(named, paramMode, typed)\n return ASTDeclaratorPtr(next=next, volatile=volatile, const=const, attrs=attrs)\n # TODO: shouldn't we parse an R-value ref here first?\n if typed and self.skip_string(\"&\"):\n attrs = []\n while 1:\n attr = self._parse_attribute()\n if attr is None:\n break\n attrs.append(attr)\n next = self._parse_declarator(named, paramMode, typed)\n return ASTDeclaratorRef(next=next, attrs=attrs)\n if typed and self.skip_string(\"...\"):\n next = self._parse_declarator(named, paramMode, False)\n return ASTDeclaratorParamPack(next=next)\n if typed and self.current_char == '(': # note: peeking, not skipping\n if paramMode == \"operatorCast\":\n # TODO: we should be able to parse cast operators which return\n # function pointers. For now, just hax it and ignore.\n return ASTDeclaratorNameParamQual(declId=None, arrayOps=[],\n paramQual=None)\n # maybe this is the beginning of params and quals,try that first,\n # otherwise assume it's noptr->declarator > ( ptr-declarator )\n pos = self.pos\n try:\n # assume this is params and quals\n res = self._parse_declarator_name_suffix(named, paramMode,\n typed)\n return res\n except DefinitionError as exParamQual:\n prevErrors.append((exParamQual,\n \"If declarator-id with parameters-and-qualifiers\"))\n self.pos = pos\n try:\n assert self.current_char == '('\n self.skip_string('(')\n # TODO: hmm, if there is a name, it must be in inner, right?\n # TODO: hmm, if there must be parameters, they must be\n # inside, right?\n inner = self._parse_declarator(named, paramMode, typed)\n if not self.skip_string(')'):\n self.fail(\"Expected ')' in \\\"( ptr-declarator )\\\"\")\n next = self._parse_declarator(named=False,\n paramMode=\"type\",\n typed=typed)\n return ASTDeclaratorParen(inner=inner, next=next)\n except DefinitionError as exNoPtrParen:\n self.pos = pos\n prevErrors.append((exNoPtrParen, \"If parenthesis in noptr-declarator\"))\n header = \"Error in declarator\"\n raise self._make_multi_error(prevErrors, header)\n if typed: # pointer to member\n pos = self.pos\n try:\n name = self._parse_nested_name(memberPointer=True)\n self.skip_ws()\n if not self.skip_string('*'):\n self.fail(\"Expected '*' in pointer to member declarator.\")\n self.skip_ws()\n except DefinitionError as e:\n self.pos = pos\n prevErrors.append((e, \"If pointer to member declarator\"))\n else:\n volatile = False\n const = False\n while 1:\n if not volatile:\n volatile = self.skip_word_and_ws('volatile')\n if volatile:\n continue\n if not const:\n const = self.skip_word_and_ws('const')\n if const:\n continue\n break\n next = self._parse_declarator(named, paramMode, typed)\n return ASTDeclaratorMemPtr(name, const, volatile, next=next)\n pos = self.pos\n try:\n res = self._parse_declarator_name_suffix(named, paramMode, typed)\n # this is a heuristic for error messages, for when there is a < after a\n # nested name, but it was not a successful template argument list\n if self.current_char == '<':\n self.otherErrors.append(self._make_multi_error(prevErrors, \"\"))\n return res\n except DefinitionError as e:\n self.pos = pos\n prevErrors.append((e, \"If declarator-id\"))\n header = \"Error in declarator or parameters-and-qualifiers\"\n raise self._make_multi_error(prevErrors, header)\n\n def _parse_initializer(self, outer: str = None, allowFallback: bool = True\n ) -> ASTInitializer:\n # initializer # global vars\n # -> brace-or-equal-initializer\n # | '(' expression-list ')'\n #\n # brace-or-equal-initializer # member vars\n # -> '=' initializer-clause\n # | braced-init-list\n #\n # initializer-clause # function params, non-type template params (with '=' in front)\n # -> assignment-expression\n # | braced-init-list\n #\n # we don't distinguish between global and member vars, so disallow paren:\n #\n # -> braced-init-list # var only\n # | '=' assignment-expression\n # | '=' braced-init-list\n self.skip_ws()\n if outer == 'member':\n bracedInit = self._parse_braced_init_list()\n if bracedInit is not None:\n return ASTInitializer(bracedInit, hasAssign=False)\n\n if not self.skip_string('='):\n return None\n\n bracedInit = self._parse_braced_init_list()\n if bracedInit is not None:\n return ASTInitializer(bracedInit)\n\n if outer == 'member':\n fallbackEnd = [] # type: List[str]\n elif outer == 'templateParam':\n fallbackEnd = [',', '>']\n elif outer is None: # function parameter\n fallbackEnd = [',', ')']\n else:\n self.fail(\"Internal error, initializer for outer '%s' not \"\n \"implemented.\" % outer)\n\n inTemplate = outer == 'templateParam'\n\n def parser() -> ASTExpression:\n return self._parse_assignment_expression(inTemplate=inTemplate)\n value = self._parse_expression_fallback(fallbackEnd, parser, allow=allowFallback)\n return ASTInitializer(value)\n\n def _parse_type(self, named: Union[bool, str], outer: str = None) -> ASTType:\n \"\"\"\n named=False|'maybe'|True: 'maybe' is e.g., for function objects which\n doesn't need to name the arguments\n\n outer == operatorCast: annoying case, we should not take the params\n \"\"\"\n if outer: # always named\n if outer not in ('type', 'member', 'function',\n 'operatorCast', 'templateParam'):\n raise Exception('Internal error, unknown outer \"%s\".' % outer)\n if outer != 'operatorCast':\n assert named\n if outer in ('type', 'function'):\n # We allow type objects to just be a name.\n # Some functions don't have normal return types: constructors,\n # destrutors, cast operators\n prevErrors = []\n startPos = self.pos\n # first try without the type\n try:\n declSpecs = self._parse_decl_specs(outer=outer, typed=False)\n decl = self._parse_declarator(named=True, paramMode=outer,\n typed=False)\n self.assert_end()\n except DefinitionError as exUntyped:\n if outer == 'type':\n desc = \"If just a name\"\n elif outer == 'function':\n desc = \"If the function has no return type\"\n else:\n assert False\n prevErrors.append((exUntyped, desc))\n self.pos = startPos\n try:\n declSpecs = self._parse_decl_specs(outer=outer)\n decl = self._parse_declarator(named=True, paramMode=outer)\n except DefinitionError as exTyped:\n self.pos = startPos\n if outer == 'type':\n desc = \"If typedef-like declaration\"\n elif outer == 'function':\n desc = \"If the function has a return type\"\n else:\n assert False\n prevErrors.append((exTyped, desc))\n # Retain the else branch for easier debugging.\n # TODO: it would be nice to save the previous stacktrace\n # and output it here.\n if True:\n if outer == 'type':\n header = \"Type must be either just a name or a \"\n header += \"typedef-like declaration.\"\n elif outer == 'function':\n header = \"Error when parsing function declaration.\"\n else:\n assert False\n raise self._make_multi_error(prevErrors, header)\n else:\n # For testing purposes.\n # do it again to get the proper traceback (how do you\n # reliably save a traceback when an exception is\n # constructed?)\n self.pos = startPos\n typed = True\n declSpecs = self._parse_decl_specs(outer=outer, typed=typed)\n decl = self._parse_declarator(named=True, paramMode=outer,\n typed=typed)\n else:\n paramMode = 'type'\n if outer == 'member': # i.e., member\n named = True\n elif outer == 'operatorCast':\n paramMode = 'operatorCast'\n outer = None\n elif outer == 'templateParam':\n named = 'single'\n declSpecs = self._parse_decl_specs(outer=outer)\n decl = self._parse_declarator(named=named, paramMode=paramMode)\n return ASTType(declSpecs, decl)\n\n def _parse_type_with_init(\n self, named: Union[bool, str],\n outer: str) -> Union[ASTTypeWithInit, ASTTemplateParamConstrainedTypeWithInit]:\n if outer:\n assert outer in ('type', 'member', 'function', 'templateParam')\n type = self._parse_type(outer=outer, named=named)\n if outer != 'templateParam':\n init = self._parse_initializer(outer=outer)\n return ASTTypeWithInit(type, init)\n # it could also be a constrained type parameter, e.g., C T = int&\n pos = self.pos\n eExpr = None\n try:\n init = self._parse_initializer(outer=outer, allowFallback=False)\n # note: init may be None if there is no =\n if init is None:\n return ASTTypeWithInit(type, None)\n # we parsed an expression, so we must have a , or a >,\n # otherwise the expression didn't get everything\n self.skip_ws()\n if self.current_char != ',' and self.current_char != '>':\n # pretend it didn't happen\n self.pos = pos\n init = None\n else:\n # we assume that it was indeed an expression\n return ASTTypeWithInit(type, init)\n except DefinitionError as e:\n self.pos = pos\n eExpr = e\n if not self.skip_string(\"=\"):\n return ASTTypeWithInit(type, None)\n try:\n typeInit = self._parse_type(named=False, outer=None)\n return ASTTemplateParamConstrainedTypeWithInit(type, typeInit)\n except DefinitionError as eType:\n if eExpr is None:\n raise eType\n errs = []\n errs.append((eExpr, \"If default template argument is an expression\"))\n errs.append((eType, \"If default template argument is a type\"))\n msg = \"Error in non-type template parameter\"\n msg += \" or constrained template parameter.\"\n raise self._make_multi_error(errs, msg)\n\n def _parse_type_using(self) -> ASTTypeUsing:\n name = self._parse_nested_name()\n self.skip_ws()\n if not self.skip_string('='):\n return ASTTypeUsing(name, None)\n type = self._parse_type(False, None)\n return ASTTypeUsing(name, type)\n\n def _parse_concept(self) -> ASTConcept:\n nestedName = self._parse_nested_name()\n self.skip_ws()\n initializer = self._parse_initializer('member')\n return ASTConcept(nestedName, initializer)\n\n def _parse_class(self) -> ASTClass:\n name = self._parse_nested_name()\n self.skip_ws()\n final = self.skip_word_and_ws('final')\n bases = []\n self.skip_ws()\n if self.skip_string(':'):\n while 1:\n self.skip_ws()\n visibility = None\n virtual = False\n pack = False\n if self.skip_word_and_ws('virtual'):\n virtual = True\n if self.match(_visibility_re):\n visibility = self.matched_text\n self.skip_ws()\n if not virtual and self.skip_word_and_ws('virtual'):\n virtual = True\n baseName = self._parse_nested_name()\n self.skip_ws()\n pack = self.skip_string('...')\n bases.append(ASTBaseClass(baseName, visibility, virtual, pack))\n self.skip_ws()\n if self.skip_string(','):\n continue\n else:\n break\n return ASTClass(name, final, bases)\n\n def _parse_union(self) -> ASTUnion:\n name = self._parse_nested_name()\n return ASTUnion(name)\n\n def _parse_enum(self) -> ASTEnum:\n scoped = None # is set by CPPEnumObject\n self.skip_ws()\n name = self._parse_nested_name()\n self.skip_ws()\n underlyingType = None\n if self.skip_string(':'):\n underlyingType = self._parse_type(named=False)\n return ASTEnum(name, scoped, underlyingType)\n\n def _parse_enumerator(self) -> ASTEnumerator:\n name = self._parse_nested_name()\n self.skip_ws()\n init = None\n if self.skip_string('='):\n self.skip_ws()\n\n def parser() -> ASTExpression:\n return self._parse_constant_expression(inTemplate=False)\n initVal = self._parse_expression_fallback([], parser)\n init = ASTInitializer(initVal)\n return ASTEnumerator(name, init)\n\n # ==========================================================================\n\n def _parse_template_parameter_list(self) -> ASTTemplateParams:\n # only: '<' parameter-list '>'\n # we assume that 'template' has just been parsed\n templateParams = [] # type: List[ASTTemplateParam]\n self.skip_ws()\n if not self.skip_string(\"<\"):\n self.fail(\"Expected '<' after 'template'\")\n prevErrors = []\n while 1:\n self.skip_ws()\n if self.skip_word('template'):\n # declare a tenplate template parameter\n nestedParams = self._parse_template_parameter_list()\n else:\n nestedParams = None\n self.skip_ws()\n key = None\n if self.skip_word_and_ws('typename'):\n key = 'typename'\n elif self.skip_word_and_ws('class'):\n key = 'class'\n elif nestedParams:\n self.fail(\"Expected 'typename' or 'class' after \"\n \"template template parameter list.\")\n if key:\n # declare a type or template type parameter\n self.skip_ws()\n parameterPack = self.skip_string('...')\n self.skip_ws()\n if self.match(identifier_re):\n identifier = ASTIdentifier(self.matched_text)\n else:\n identifier = None\n self.skip_ws()\n if not parameterPack and self.skip_string('='):\n default = self._parse_type(named=False, outer=None)\n else:\n default = None\n data = ASTTemplateKeyParamPackIdDefault(key, identifier,\n parameterPack, default)\n if nestedParams:\n # template type\n templateParams.append(\n ASTTemplateParamTemplateType(nestedParams, data))\n else:\n # type\n templateParams.append(ASTTemplateParamType(data))\n else:\n # declare a non-type parameter, or constrained type parameter\n pos = self.pos\n try:\n param = self._parse_type_with_init('maybe', 'templateParam')\n templateParams.append(ASTTemplateParamNonType(param))\n except DefinitionError as e:\n msg = \"If non-type template parameter or constrained template parameter\"\n prevErrors.append((e, msg))\n self.pos = pos\n self.skip_ws()\n if self.skip_string('>'):\n return ASTTemplateParams(templateParams)\n elif self.skip_string(','):\n prevErrors = []\n continue\n else:\n header = \"Error in template parameter list.\"\n try:\n self.fail('Expected \"=\", \",\", or \">\".')\n except DefinitionError as e:\n prevErrors.append((e, \"\"))\n raise self._make_multi_error(prevErrors, header)\n\n def _parse_template_introduction(self) -> ASTTemplateIntroduction:\n pos = self.pos\n try:\n concept = self._parse_nested_name()\n except Exception:\n self.pos = pos\n return None\n self.skip_ws()\n if not self.skip_string('{'):\n self.pos = pos\n return None\n\n # for sure it must be a template introduction now\n params = []\n while 1:\n self.skip_ws()\n parameterPack = self.skip_string('...')\n self.skip_ws()\n if not self.match(identifier_re):\n self.fail(\"Expected identifier in template introduction list.\")\n txt_identifier = self.matched_text\n # make sure there isn't a keyword\n if txt_identifier in _keywords:\n self.fail(\"Expected identifier in template introduction list, \"\n \"got keyword: %s\" % txt_identifier)\n identifier = ASTIdentifier(txt_identifier)\n params.append(ASTTemplateIntroductionParameter(identifier, parameterPack))\n\n self.skip_ws()\n if self.skip_string('}'):\n break\n elif self.skip_string(','):\n continue\n else:\n self.fail(\"Error in template introduction list. \"\n 'Expected \",\", or \"}\".')\n return ASTTemplateIntroduction(concept, params)\n\n def _parse_template_declaration_prefix(self, objectType: str\n ) -> ASTTemplateDeclarationPrefix:\n templates = [] # type: List[Union[ASTTemplateParams, ASTTemplateIntroduction]]\n while 1:\n self.skip_ws()\n # the saved position is only used to provide a better error message\n params = None # type: Union[ASTTemplateParams, ASTTemplateIntroduction]\n pos = self.pos\n if self.skip_word(\"template\"):\n try:\n params = self._parse_template_parameter_list()\n except DefinitionError as e:\n if objectType == 'member' and len(templates) == 0:\n return ASTTemplateDeclarationPrefix(None)\n else:\n raise e\n else:\n params = self._parse_template_introduction()\n if not params:\n break\n if objectType == 'concept' and len(templates) > 0:\n self.pos = pos\n self.fail(\"More than 1 template parameter list for concept.\")\n templates.append(params)\n if len(templates) == 0 and objectType == 'concept':\n self.fail('Missing template parameter list for concept.')\n if len(templates) == 0:\n return None\n else:\n return ASTTemplateDeclarationPrefix(templates)\n\n def _check_template_consistency(self, nestedName: ASTNestedName,\n templatePrefix: ASTTemplateDeclarationPrefix,\n fullSpecShorthand: bool, isMember: bool = False\n ) -> ASTTemplateDeclarationPrefix:\n numArgs = nestedName.num_templates()\n isMemberInstantiation = False\n if not templatePrefix:\n numParams = 0\n else:\n if isMember and templatePrefix.templates is None:\n numParams = 0\n isMemberInstantiation = True\n else:\n numParams = len(templatePrefix.templates)\n if numArgs + 1 < numParams:\n self.fail(\"Too few template argument lists comapred to parameter\"\n \" lists. Argument lists: %d, Parameter lists: %d.\"\n % (numArgs, numParams))\n if numArgs > numParams:\n numExtra = numArgs - numParams\n if not fullSpecShorthand and not isMemberInstantiation:\n msg = \"Too many template argument lists compared to parameter\" \\\n \" lists. Argument lists: %d, Parameter lists: %d,\" \\\n \" Extra empty parameters lists prepended: %d.\" \\\n % (numArgs, numParams, numExtra)\n msg += \" Declaration:\\n\\t\"\n if templatePrefix:\n msg += \"%s\\n\\t\" % templatePrefix\n msg += str(nestedName)\n self.warn(msg)\n\n newTemplates = [] # type: List[Union[ASTTemplateParams, ASTTemplateIntroduction]]\n for i in range(numExtra):\n newTemplates.append(ASTTemplateParams([]))\n if templatePrefix and not isMemberInstantiation:\n newTemplates.extend(templatePrefix.templates)\n templatePrefix = ASTTemplateDeclarationPrefix(newTemplates)\n return templatePrefix\n\n def parse_declaration(self, objectType: str, directiveType: str) -> ASTDeclaration:\n if objectType not in ('class', 'union', 'function', 'member', 'type',\n 'concept', 'enum', 'enumerator'):\n raise Exception('Internal error, unknown objectType \"%s\".' % objectType)\n if directiveType not in ('class', 'struct', 'union', 'function', 'member', 'var',\n 'type', 'concept',\n 'enum', 'enum-struct', 'enum-class', 'enumerator'):\n raise Exception('Internal error, unknown directiveType \"%s\".' % directiveType)\n visibility = None\n templatePrefix = None\n declaration = None # type: Any\n\n self.skip_ws()\n if self.match(_visibility_re):\n visibility = self.matched_text\n\n if objectType in ('type', 'concept', 'member', 'function', 'class'):\n templatePrefix = self._parse_template_declaration_prefix(objectType)\n\n if objectType == 'type':\n prevErrors = []\n pos = self.pos\n try:\n if not templatePrefix:\n declaration = self._parse_type(named=True, outer='type')\n except DefinitionError as e:\n prevErrors.append((e, \"If typedef-like declaration\"))\n self.pos = pos\n pos = self.pos\n try:\n if not declaration:\n declaration = self._parse_type_using()\n except DefinitionError as e:\n self.pos = pos\n prevErrors.append((e, \"If type alias or template alias\"))\n header = \"Error in type declaration.\"\n raise self._make_multi_error(prevErrors, header)\n elif objectType == 'concept':\n declaration = self._parse_concept()\n elif objectType == 'member':\n declaration = self._parse_type_with_init(named=True, outer='member')\n elif objectType == 'function':\n declaration = self._parse_type(named=True, outer='function')\n elif objectType == 'class':\n declaration = self._parse_class()\n elif objectType == 'union':\n declaration = self._parse_union()\n elif objectType == 'enum':\n declaration = self._parse_enum()\n elif objectType == 'enumerator':\n declaration = self._parse_enumerator()\n else:\n assert False\n templatePrefix = self._check_template_consistency(declaration.name,\n templatePrefix,\n fullSpecShorthand=False,\n isMember=objectType == 'member')\n return ASTDeclaration(objectType, directiveType, visibility,\n templatePrefix, declaration)\n\n def parse_namespace_object(self) -> ASTNamespace:\n templatePrefix = self._parse_template_declaration_prefix(objectType=\"namespace\")\n name = self._parse_nested_name()\n templatePrefix = self._check_template_consistency(name, templatePrefix,\n fullSpecShorthand=False)\n res = ASTNamespace(name, templatePrefix)\n res.objectType = 'namespace' # type: ignore\n return res\n\n def parse_xref_object(self) -> Tuple[Union[ASTNamespace, ASTDeclaration], bool]:\n pos = self.pos\n try:\n templatePrefix = self._parse_template_declaration_prefix(objectType=\"xref\")\n name = self._parse_nested_name()\n # if there are '()' left, just skip them\n self.skip_ws()\n self.skip_string('()')\n self.assert_end()\n templatePrefix = self._check_template_consistency(name, templatePrefix,\n fullSpecShorthand=True)\n res1 = ASTNamespace(name, templatePrefix)\n res1.objectType = 'xref' # type: ignore\n return res1, True\n except DefinitionError as e1:\n try:\n self.pos = pos\n res2 = self.parse_declaration('function', 'function')\n # if there are '()' left, just skip them\n self.skip_ws()\n self.skip_string('()')\n self.assert_end()\n return res2, False\n except DefinitionError as e2:\n errs = []\n errs.append((e1, \"If shorthand ref\"))\n errs.append((e2, \"If full function ref\"))\n msg = \"Error in cross-reference.\"\n raise self._make_multi_error(errs, msg)\n\n def parse_expression(self) -> Union[ASTExpression, ASTType]:\n pos = self.pos\n try:\n expr = self._parse_expression()\n self.skip_ws()\n self.assert_end()\n return expr\n except DefinitionError as exExpr:\n self.pos = pos\n try:\n typ = self._parse_type(False)\n self.skip_ws()\n self.assert_end()\n return typ\n except DefinitionError as exType:\n header = \"Error when parsing (type) expression.\"\n errs = []\n errs.append((exExpr, \"If expression\"))\n errs.append((exType, \"If type\"))\n raise self._make_multi_error(errs, header)\n\n\ndef _make_phony_error_name() -> ASTNestedName:\n nne = ASTNestedNameElement(ASTIdentifier(\"PhonyNameDueToError\"), None)\n return ASTNestedName([nne], [False], rooted=False)\n\n\nclass CPPObject(ObjectDescription):\n \"\"\"Description of a C++ language object.\"\"\"\n\n doc_field_types = [\n GroupedField('parameter', label=_('Parameters'),\n names=('param', 'parameter', 'arg', 'argument'),\n can_collapse=True),\n GroupedField('template parameter', label=_('Template Parameters'),\n names=('tparam', 'template parameter'),\n can_collapse=True),\n GroupedField('exceptions', label=_('Throws'), rolename='cpp:class',\n names=('throws', 'throw', 'exception'),\n can_collapse=True),\n Field('returnvalue', label=_('Returns'), has_arg=False,\n names=('returns', 'return')),\n ]\n\n option_spec = dict(ObjectDescription.option_spec)\n option_spec['tparam-line-spec'] = directives.flag\n\n def _add_enumerator_to_parent(self, ast: ASTDeclaration) -> None:\n assert ast.objectType == 'enumerator'\n # find the parent, if it exists && is an enum\n # && it's unscoped,\n # then add the name to the parent scope\n symbol = ast.symbol\n assert symbol\n assert symbol.identOrOp is not None\n assert symbol.templateParams is None\n assert symbol.templateArgs is None\n parentSymbol = symbol.parent\n assert parentSymbol\n if parentSymbol.parent is None:\n # TODO: we could warn, but it is somewhat equivalent to unscoped\n # enums, without the enum\n return # no parent\n parentDecl = parentSymbol.declaration\n if parentDecl is None:\n # the parent is not explicitly declared\n # TODO: we could warn, but it could be a style to just assume\n # enumerator parents to be scoped\n return\n if parentDecl.objectType != 'enum':\n # TODO: maybe issue a warning, enumerators in non-enums is weird,\n # but it is somewhat equivalent to unscoped enums, without the enum\n return\n if parentDecl.directiveType != 'enum':\n return\n\n targetSymbol = parentSymbol.parent\n s = targetSymbol.find_identifier(symbol.identOrOp, matchSelf=False, recurseInAnon=True,\n searchInSiblings=False)\n if s is not None:\n # something is already declared with that name\n return\n declClone = symbol.declaration.clone()\n declClone.enumeratorScopedSymbol = symbol\n Symbol(parent=targetSymbol, identOrOp=symbol.identOrOp,\n templateParams=None, templateArgs=None,\n declaration=declClone,\n docname=self.env.docname)\n\n def add_target_and_index(self, ast: ASTDeclaration, sig: str,\n signode: TextElement) -> None:\n # general note: name must be lstrip(':')'ed, to remove \"::\"\n ids = []\n for i in range(1, _max_id + 1):\n try:\n id = ast.get_id(version=i)\n ids.append(id)\n except NoOldIdError:\n assert i < _max_id\n # let's keep the newest first\n ids = list(reversed(ids))\n newestId = ids[0]\n assert newestId # shouldn't be None\n if not re.compile(r'^[a-zA-Z0-9_]*$').match(newestId):\n logger.warning('Index id generation for C++ object \"%s\" failed, please '\n 'report as bug (id=%s).', ast, newestId,\n location=self.get_source_info())\n\n name = ast.symbol.get_full_nested_name().get_display_string().lstrip(':')\n # Add index entry, but not if it's a declaration inside a concept\n isInConcept = False\n s = ast.symbol.parent\n while s is not None:\n decl = s.declaration\n s = s.parent\n if decl is None:\n continue\n if decl.objectType == 'concept':\n isInConcept = True\n break\n if not isInConcept:\n strippedName = name\n for prefix in self.env.config.cpp_index_common_prefix:\n if name.startswith(prefix):\n strippedName = strippedName[len(prefix):]\n break\n indexText = self.get_index_text(strippedName)\n self.indexnode['entries'].append(('single', indexText, newestId, '', None))\n\n if newestId not in self.state.document.ids:\n # if the name is not unique, the first one will win\n names = self.env.domaindata['cpp']['names']\n if name not in names:\n names[name] = ast.symbol.docname\n # always add the newest id\n assert newestId\n signode['ids'].append(newestId)\n # only add compatibility ids when there are no conflicts\n for id in ids[1:]:\n if not id: # is None when the element didn't exist in that version\n continue\n if id not in self.state.document.ids:\n signode['ids'].append(id)\n self.state.document.note_explicit_target(signode)\n\n @property\n def object_type(self) -> str:\n raise NotImplementedError()\n\n @property\n def display_object_type(self) -> str:\n return self.object_type\n\n def get_index_text(self, name: str) -> str:\n return _('%s (C++ %s)') % (name, self.display_object_type)\n\n def parse_definition(self, parser: DefinitionParser) -> ASTDeclaration:\n return parser.parse_declaration(self.object_type, self.objtype)\n\n def describe_signature(self, signode: desc_signature,\n ast: ASTDeclaration, options: Dict) -> None:\n ast.describe_signature(signode, 'lastIsName', self.env, options)\n\n def run(self) -> List[Node]:\n env = self.state.document.settings.env # from ObjectDescription.run\n if 'cpp:parent_symbol' not in env.temp_data:\n root = env.domaindata['cpp']['root_symbol']\n env.temp_data['cpp:parent_symbol'] = root\n env.ref_context['cpp:parent_key'] = root.get_lookup_key()\n\n # The lookup keys assume that no nested scopes exists inside overloaded functions.\n # (see also #5191)\n # Example:\n # .. cpp:function:: void f(int)\n # .. cpp:function:: void f(double)\n #\n # .. cpp:function:: void g()\n #\n # :cpp:any:`boom`\n #\n # So we disallow any signatures inside functions.\n parentSymbol = env.temp_data['cpp:parent_symbol']\n parentDecl = parentSymbol.declaration\n if parentDecl is not None and parentDecl.objectType == 'function':\n logger.warning(\"C++ declarations inside functions are not supported.\" +\n \" Parent function is \" +\n str(parentSymbol.get_full_nested_name()),\n location=self.get_source_info())\n name = _make_phony_error_name()\n symbol = parentSymbol.add_name(name)\n env.temp_data['cpp:last_symbol'] = symbol\n return []\n # When multiple declarations are made in the same directive\n # they need to know about each other to provide symbol lookup for function parameters.\n # We use last_symbol to store the latest added declaration in a directive.\n env.temp_data['cpp:last_symbol'] = None\n return super().run()\n\n def handle_signature(self, sig: str, signode: desc_signature) -> ASTDeclaration:\n parentSymbol = self.env.temp_data['cpp:parent_symbol']\n\n parser = DefinitionParser(sig, location=signode, config=self.env.config)\n try:\n ast = self.parse_definition(parser)\n parser.assert_end()\n except DefinitionError as e:\n logger.warning(e, location=signode)\n # It is easier to assume some phony name than handling the error in\n # the possibly inner declarations.\n name = _make_phony_error_name()\n symbol = parentSymbol.add_name(name)\n self.env.temp_data['cpp:last_symbol'] = symbol\n raise ValueError\n\n try:\n symbol = parentSymbol.add_declaration(ast, docname=self.env.docname)\n # append the new declaration to the sibling list\n assert symbol.siblingAbove is None\n assert symbol.siblingBelow is None\n symbol.siblingAbove = self.env.temp_data['cpp:last_symbol']\n if symbol.siblingAbove is not None:\n assert symbol.siblingAbove.siblingBelow is None\n symbol.siblingAbove.siblingBelow = symbol\n self.env.temp_data['cpp:last_symbol'] = symbol\n except _DuplicateSymbolError as e:\n # Assume we are actually in the old symbol,\n # instead of the newly created duplicate.\n self.env.temp_data['cpp:last_symbol'] = e.symbol\n logger.warning(\"Duplicate declaration, %s\", sig, location=signode)\n\n if ast.objectType == 'enumerator':\n self._add_enumerator_to_parent(ast)\n\n # note: handle_signature may be called multiple time per directive,\n # if it has multiple signatures, so don't mess with the original options.\n options = dict(self.options)\n options['tparam-line-spec'] = 'tparam-line-spec' in self.options\n self.describe_signature(signode, ast, options)\n return ast\n\n def before_content(self) -> None:\n lastSymbol = self.env.temp_data['cpp:last_symbol'] # type: Symbol\n assert lastSymbol\n self.oldParentSymbol = self.env.temp_data['cpp:parent_symbol']\n self.oldParentKey = self.env.ref_context['cpp:parent_key'] # type: LookupKey\n self.env.temp_data['cpp:parent_symbol'] = lastSymbol\n self.env.ref_context['cpp:parent_key'] = lastSymbol.get_lookup_key()\n\n def after_content(self) -> None:\n self.env.temp_data['cpp:parent_symbol'] = self.oldParentSymbol\n self.env.ref_context['cpp:parent_key'] = self.oldParentKey\n\n\nclass CPPTypeObject(CPPObject):\n object_type = 'type'\n\n\nclass CPPConceptObject(CPPObject):\n object_type = 'concept'\n\n\nclass CPPMemberObject(CPPObject):\n object_type = 'member'\n\n\nclass CPPFunctionObject(CPPObject):\n object_type = 'function'\n\n\nclass CPPClassObject(CPPObject):\n object_type = 'class'\n\n @property\n def display_object_type(self) -> str:\n # the distinction between class and struct is only cosmetic\n assert self.objtype in ('class', 'struct')\n return self.objtype\n\n\nclass CPPUnionObject(CPPObject):\n object_type = 'union'\n\n\nclass CPPEnumObject(CPPObject):\n object_type = 'enum'\n\n\nclass CPPEnumeratorObject(CPPObject):\n object_type = 'enumerator'\n\n\nclass CPPNamespaceObject(SphinxDirective):\n \"\"\"\n This directive is just to tell Sphinx that we're documenting stuff in\n namespace foo.\n \"\"\"\n\n has_content = False\n required_arguments = 1\n optional_arguments = 0\n final_argument_whitespace = True\n option_spec = {} # type: Dict\n\n def run(self) -> List[Node]:\n rootSymbol = self.env.domaindata['cpp']['root_symbol']\n if self.arguments[0].strip() in ('NULL', '0', 'nullptr'):\n symbol = rootSymbol\n stack = [] # type: List[Symbol]\n else:\n parser = DefinitionParser(self.arguments[0],\n location=self.get_source_info(),\n config=self.config)\n try:\n ast = parser.parse_namespace_object()\n parser.assert_end()\n except DefinitionError as e:\n logger.warning(e, location=self.get_source_info())\n name = _make_phony_error_name()\n ast = ASTNamespace(name, None)\n symbol = rootSymbol.add_name(ast.nestedName, ast.templatePrefix)\n stack = [symbol]\n self.env.temp_data['cpp:parent_symbol'] = symbol\n self.env.temp_data['cpp:namespace_stack'] = stack\n self.env.ref_context['cpp:parent_key'] = symbol.get_lookup_key()\n return []\n\n\nclass CPPNamespacePushObject(SphinxDirective):\n has_content = False\n required_arguments = 1\n optional_arguments = 0\n final_argument_whitespace = True\n option_spec = {} # type: Dict\n\n def run(self) -> List[Node]:\n if self.arguments[0].strip() in ('NULL', '0', 'nullptr'):\n return []\n parser = DefinitionParser(self.arguments[0],\n location=self.get_source_info(),\n config=self.config)\n try:\n ast = parser.parse_namespace_object()\n parser.assert_end()\n except DefinitionError as e:\n logger.warning(e, location=self.get_source_info())\n name = _make_phony_error_name()\n ast = ASTNamespace(name, None)\n oldParent = self.env.temp_data.get('cpp:parent_symbol', None)\n if not oldParent:\n oldParent = self.env.domaindata['cpp']['root_symbol']\n symbol = oldParent.add_name(ast.nestedName, ast.templatePrefix)\n stack = self.env.temp_data.get('cpp:namespace_stack', [])\n stack.append(symbol)\n self.env.temp_data['cpp:parent_symbol'] = symbol\n self.env.temp_data['cpp:namespace_stack'] = stack\n self.env.ref_context['cpp:parent_key'] = symbol.get_lookup_key()\n return []\n\n\nclass CPPNamespacePopObject(SphinxDirective):\n has_content = False\n required_arguments = 0\n optional_arguments = 0\n final_argument_whitespace = True\n option_spec = {} # type: Dict\n\n def run(self) -> List[Node]:\n stack = self.env.temp_data.get('cpp:namespace_stack', None)\n if not stack or len(stack) == 0:\n logger.warning(\"C++ namespace pop on empty stack. Defaulting to gobal scope.\",\n location=self.get_source_info())\n stack = []\n else:\n stack.pop()\n if len(stack) > 0:\n symbol = stack[-1]\n else:\n symbol = self.env.domaindata['cpp']['root_symbol']\n self.env.temp_data['cpp:parent_symbol'] = symbol\n self.env.temp_data['cpp:namespace_stack'] = stack\n self.env.ref_context['cpp:parent_key'] = symbol.get_lookup_key()\n return []\n\n\nclass AliasNode(nodes.Element):\n def __init__(self, sig: str, env: \"BuildEnvironment\" = None,\n parentKey: LookupKey = None) -> None:\n super().__init__()\n self.sig = sig\n if env is not None:\n if 'cpp:parent_symbol' not in env.temp_data:\n root = env.domaindata['cpp']['root_symbol']\n env.temp_data['cpp:parent_symbol'] = root\n self.parentKey = env.temp_data['cpp:parent_symbol'].get_lookup_key()\n else:\n assert parentKey is not None\n self.parentKey = parentKey\n\n def copy(self: T) -> T:\n return self.__class__(self.sig, env=None, parentKey=self.parentKey) # type: ignore\n\n\nclass AliasTransform(SphinxTransform):\n default_priority = ReferencesResolver.default_priority - 1\n\n def apply(self, **kwargs: Any) -> None:\n for node in self.document.traverse(AliasNode):\n sig = node.sig\n parentKey = node.parentKey\n try:\n parser = DefinitionParser(sig, location=node,\n config=self.env.config)\n ast, isShorthand = parser.parse_xref_object()\n parser.assert_end()\n except DefinitionError as e:\n logger.warning(e, location=node)\n ast, isShorthand = None, None\n\n if ast is None:\n # could not be parsed, so stop here\n signode = addnodes.desc_signature(sig, '')\n signode.clear()\n signode += addnodes.desc_name(sig, sig)\n node.replace_self(signode)\n continue\n\n rootSymbol = self.env.domains['cpp'].data['root_symbol'] # type: Symbol\n parentSymbol = rootSymbol.direct_lookup(parentKey) # type: Symbol\n if not parentSymbol:\n print(\"Target: \", sig)\n print(\"ParentKey: \", parentKey)\n print(rootSymbol.dump(1))\n assert parentSymbol # should be there\n\n symbols = [] # type: List[Symbol]\n if isShorthand:\n assert isinstance(ast, ASTNamespace)\n ns = ast\n name = ns.nestedName\n if ns.templatePrefix:\n templateDecls = ns.templatePrefix.templates\n else:\n templateDecls = []\n symbols, failReason = parentSymbol.find_name(\n nestedName=name,\n templateDecls=templateDecls,\n typ='any',\n templateShorthand=True,\n matchSelf=True, recurseInAnon=True,\n searchInSiblings=False)\n if symbols is None:\n symbols = []\n else:\n assert isinstance(ast, ASTDeclaration)\n decl = ast\n name = decl.name\n s = parentSymbol.find_declaration(decl, 'any',\n templateShorthand=True,\n matchSelf=True, recurseInAnon=True)\n if s is not None:\n symbols.append(s)\n\n symbols = [s for s in symbols if s.declaration is not None]\n\n if len(symbols) == 0:\n signode = addnodes.desc_signature(sig, '')\n node.append(signode)\n signode.clear()\n signode += addnodes.desc_name(sig, sig)\n\n logger.warning(\"Could not find C++ declaration for alias '%s'.\" % ast,\n location=node)\n node.replace_self(signode)\n else:\n nodes = []\n options = dict()\n options['tparam-line-spec'] = False\n for s in symbols:\n signode = addnodes.desc_signature(sig, '')\n nodes.append(signode)\n s.declaration.describe_signature(signode, 'markName', self.env, options)\n node.replace_self(nodes)\n\n\nclass CPPAliasObject(ObjectDescription):\n option_spec = {} # type: Dict\n\n# MASKED: run function (lines 6818-6847)\n\n\nclass CPPXRefRole(XRefRole):\n def process_link(self, env: BuildEnvironment, refnode: Element, has_explicit_title: bool,\n title: str, target: str) -> Tuple[str, str]:\n refnode.attributes.update(env.ref_context)\n\n if not has_explicit_title:\n # major hax: replace anon names via simple string manipulation.\n # Can this actually fail?\n title = anon_identifier_re.sub(\"[anonymous]\", str(title))\n\n if refnode['reftype'] == 'any':\n # Assume the removal part of fix_parens for :any: refs.\n # The addition part is done with the reference is resolved.\n if not has_explicit_title and title.endswith('()'):\n title = title[:-2]\n if target.endswith('()'):\n target = target[:-2]\n # TODO: should this really be here?\n if not has_explicit_title:\n target = target.lstrip('~') # only has a meaning for the title\n # if the first character is a tilde, don't display the module/class\n # parts of the contents\n if title[:1] == '~':\n title = title[1:]\n dcolon = title.rfind('::')\n if dcolon != -1:\n title = title[dcolon + 2:]\n return title, target\n\n\nclass CPPExprRole(SphinxRole):\n def __init__(self, asCode: bool) -> None:\n super().__init__()\n if asCode:\n # render the expression as inline code\n self.class_type = 'cpp-expr'\n self.node_type = nodes.literal # type: Type[TextElement]\n else:\n # render the expression as inline text\n self.class_type = 'cpp-texpr'\n self.node_type = nodes.inline\n\n def run(self) -> Tuple[List[Node], List[system_message]]:\n text = self.text.replace('\\n', ' ')\n parser = DefinitionParser(text,\n location=self.get_source_info(),\n config=self.config)\n # attempt to mimic XRefRole classes, except that...\n classes = ['xref', 'cpp', self.class_type]\n try:\n ast = parser.parse_expression()\n except DefinitionError as ex:\n logger.warning('Unparseable C++ expression: %r\\n%s', text, ex,\n location=self.get_source_info())\n # see below\n return [self.node_type(text, text, classes=classes)], []\n parentSymbol = self.env.temp_data.get('cpp:parent_symbol', None)\n if parentSymbol is None:\n parentSymbol = self.env.domaindata['cpp']['root_symbol']\n # ...most if not all of these classes should really apply to the individual references,\n # not the container node\n signode = self.node_type(classes=classes)\n ast.describe_signature(signode, 'markType', self.env, parentSymbol)\n return [signode], []\n\n\nclass CPPDomain(Domain):\n \"\"\"C++ language domain.\n\n There are two 'object type' attributes being used::\n\n - Each object created from directives gets an assigned .objtype from ObjectDescription.run.\n This is simply the directive name.\n - Each declaration (see the distinction in the directives dict below) has a nested .ast of\n type ASTDeclaration. That object has .objectType which corresponds to the keys in the\n object_types dict below. They are the core different types of declarations in C++ that\n one can document.\n \"\"\"\n name = 'cpp'\n label = 'C++'\n object_types = {\n 'class': ObjType(_('class'), 'class', 'type', 'identifier'),\n 'union': ObjType(_('union'), 'union', 'type', 'identifier'),\n 'function': ObjType(_('function'), 'function', 'func', 'type', 'identifier'),\n 'member': ObjType(_('member'), 'member', 'var'),\n 'type': ObjType(_('type'), 'type', 'identifier'),\n 'concept': ObjType(_('concept'), 'concept', 'identifier'),\n 'enum': ObjType(_('enum'), 'enum', 'type', 'identifier'),\n 'enumerator': ObjType(_('enumerator'), 'enumerator')\n }\n\n directives = {\n # declarations\n 'class': CPPClassObject,\n 'struct': CPPClassObject,\n 'union': CPPUnionObject,\n 'function': CPPFunctionObject,\n 'member': CPPMemberObject,\n 'var': CPPMemberObject,\n 'type': CPPTypeObject,\n 'concept': CPPConceptObject,\n 'enum': CPPEnumObject,\n 'enum-struct': CPPEnumObject,\n 'enum-class': CPPEnumObject,\n 'enumerator': CPPEnumeratorObject,\n # scope control\n 'namespace': CPPNamespaceObject,\n 'namespace-push': CPPNamespacePushObject,\n 'namespace-pop': CPPNamespacePopObject,\n # other\n 'alias': CPPAliasObject\n }\n roles = {\n 'any': CPPXRefRole(),\n 'class': CPPXRefRole(),\n 'struct': CPPXRefRole(),\n 'union': CPPXRefRole(),\n 'func': CPPXRefRole(fix_parens=True),\n 'member': CPPXRefRole(),\n 'var': CPPXRefRole(),\n 'type': CPPXRefRole(),\n 'concept': CPPXRefRole(),\n 'enum': CPPXRefRole(),\n 'enumerator': CPPXRefRole(),\n 'expr': CPPExprRole(asCode=True),\n 'texpr': CPPExprRole(asCode=False)\n }\n initial_data = {\n 'root_symbol': Symbol(None, None, None, None, None, None),\n 'names': {} # full name for indexing -> docname\n }\n\n def clear_doc(self, docname: str) -> None:\n if Symbol.debug_show_tree:\n print(\"clear_doc:\", docname)\n print(\"\\tbefore:\")\n print(self.data['root_symbol'].dump(1))\n print(\"\\tbefore end\")\n\n rootSymbol = self.data['root_symbol']\n rootSymbol.clear_doc(docname)\n\n if Symbol.debug_show_tree:\n print(\"\\tafter:\")\n print(self.data['root_symbol'].dump(1))\n print(\"\\tafter end\")\n print(\"clear_doc end:\", docname)\n for name, nDocname in list(self.data['names'].items()):\n if nDocname == docname:\n del self.data['names'][name]\n\n def process_doc(self, env: BuildEnvironment, docname: str,\n document: nodes.document) -> None:\n if Symbol.debug_show_tree:\n print(\"process_doc:\", docname)\n print(self.data['root_symbol'].dump(0))\n print(\"process_doc end:\", docname)\n\n def process_field_xref(self, pnode: pending_xref) -> None:\n pnode.attributes.update(self.env.ref_context)\n\n def merge_domaindata(self, docnames: List[str], otherdata: Dict) -> None:\n if Symbol.debug_show_tree:\n print(\"merge_domaindata:\")\n print(\"\\tself:\")\n print(self.data['root_symbol'].dump(1))\n print(\"\\tself end\")\n print(\"\\tother:\")\n print(otherdata['root_symbol'].dump(1))\n print(\"\\tother end\")\n\n self.data['root_symbol'].merge_with(otherdata['root_symbol'],\n docnames, self.env)\n ourNames = self.data['names']\n for name, docname in otherdata['names'].items():\n if docname in docnames:\n if name in ourNames:\n msg = __(\"Duplicate declaration, also defined in '%s'.\\n\"\n \"Name of declaration is '%s'.\")\n msg = msg % (ourNames[name], name)\n logger.warning(msg, location=docname)\n else:\n ourNames[name] = docname\n if Symbol.debug_show_tree:\n print(\"\\tresult:\")\n print(self.data['root_symbol'].dump(1))\n print(\"\\tresult end\")\n print(\"merge_domaindata end\")\n\n def _resolve_xref_inner(self, env: BuildEnvironment, fromdocname: str, builder: Builder,\n typ: str, target: str, node: pending_xref,\n contnode: Element) -> Tuple[Element, str]:\n # add parens again for those that could be functions\n if typ == 'any' or typ == 'func':\n target += '()'\n parser = DefinitionParser(target, location=node, config=env.config)\n try:\n ast, isShorthand = parser.parse_xref_object()\n except DefinitionError as e:\n # as arg to stop flake8 from complaining\n def findWarning(e: Exception) -> Tuple[str, Exception]:\n if typ != 'any' and typ != 'func':\n return target, e\n # hax on top of the paren hax to try to get correct errors\n parser2 = DefinitionParser(target[:-2],\n location=node,\n config=env.config)\n try:\n parser2.parse_xref_object()\n except DefinitionError as e2:\n return target[:-2], e2\n # strange, that we don't get the error now, use the original\n return target, e\n t, ex = findWarning(e)\n logger.warning('Unparseable C++ cross-reference: %r\\n%s', t, ex,\n location=node)\n return None, None\n parentKey = node.get(\"cpp:parent_key\", None) # type: LookupKey\n rootSymbol = self.data['root_symbol']\n if parentKey:\n parentSymbol = rootSymbol.direct_lookup(parentKey) # type: Symbol\n if not parentSymbol:\n print(\"Target: \", target)\n print(\"ParentKey: \", parentKey.data)\n print(rootSymbol.dump(1))\n assert parentSymbol # should be there\n else:\n parentSymbol = rootSymbol\n\n if isShorthand:\n assert isinstance(ast, ASTNamespace)\n ns = ast\n name = ns.nestedName\n if ns.templatePrefix:\n templateDecls = ns.templatePrefix.templates\n else:\n templateDecls = []\n # let's be conservative with the sibling lookup for now\n searchInSiblings = (not name.rooted) and len(name.names) == 1\n symbols, failReason = parentSymbol.find_name(\n name, templateDecls, typ,\n templateShorthand=True,\n matchSelf=True, recurseInAnon=True,\n searchInSiblings=searchInSiblings)\n if symbols is None:\n if typ == 'identifier':\n if failReason == 'templateParamInQualified':\n # this is an xref we created as part of a signature,\n # so don't warn for names nested in template parameters\n raise NoUri(str(name), typ)\n s = None\n else:\n # just refer to the arbitrarily first symbol\n s = symbols[0]\n else:\n assert isinstance(ast, ASTDeclaration)\n decl = ast\n name = decl.name\n s = parentSymbol.find_declaration(decl, typ,\n templateShorthand=True,\n matchSelf=True, recurseInAnon=True)\n if s is None or s.declaration is None:\n txtName = str(name)\n if txtName.startswith('std::') or txtName == 'std':\n raise NoUri(txtName, typ)\n return None, None\n\n if typ.startswith('cpp:'):\n typ = typ[4:]\n origTyp = typ\n if typ == 'func':\n typ = 'function'\n if typ == 'struct':\n typ = 'class'\n declTyp = s.declaration.objectType\n\n def checkType() -> bool:\n if typ == 'any' or typ == 'identifier':\n return True\n if declTyp == 'templateParam':\n # TODO: perhaps this should be strengthened one day\n return True\n if declTyp == 'functionParam':\n if typ == 'var' or typ == 'member':\n return True\n objtypes = self.objtypes_for_role(typ)\n if objtypes:\n return declTyp in objtypes\n print(\"Type is %s (originally: %s), declType is %s\" % (typ, origTyp, declTyp))\n assert False\n if not checkType():\n logger.warning(\"cpp:%s targets a %s (%s).\",\n origTyp, s.declaration.objectType,\n s.get_full_nested_name(),\n location=node)\n\n declaration = s.declaration\n if isShorthand:\n fullNestedName = s.get_full_nested_name()\n displayName = fullNestedName.get_display_string().lstrip(':')\n else:\n displayName = decl.get_display_string()\n docname = s.docname\n assert docname\n\n # the non-identifier refs are cross-references, which should be processed:\n # - fix parenthesis due to operator() and add_function_parentheses\n if typ != \"identifier\":\n title = contnode.pop(0).astext()\n # If it's operator(), we need to add '()' if explicit function parens\n # are requested. Then the Sphinx machinery will add another pair.\n # Also, if it's an 'any' ref that resolves to a function, we need to add\n # parens as well.\n # However, if it's a non-shorthand function ref, for a function that\n # takes no arguments, then we may need to add parens again as well.\n addParen = 0\n if not node.get('refexplicit', False) and declaration.objectType == 'function':\n if isShorthand:\n # this is just the normal haxing for 'any' roles\n if env.config.add_function_parentheses and typ == 'any':\n addParen += 1\n # and now this stuff for operator()\n if (env.config.add_function_parentheses and typ == 'function' and\n title.endswith('operator()')):\n addParen += 1\n if ((typ == 'any' or typ == 'function') and\n title.endswith('operator') and\n displayName.endswith('operator()')):\n addParen += 1\n else:\n # our job here is to essentially nullify add_function_parentheses\n if env.config.add_function_parentheses:\n if typ == 'any' and displayName.endswith('()'):\n addParen += 1\n elif typ == 'function':\n if title.endswith('()') and not displayName.endswith('()'):\n title = title[:-2]\n else:\n if displayName.endswith('()'):\n addParen += 1\n if addParen > 0:\n title += '()' * addParen\n # and reconstruct the title again\n contnode += nodes.Text(title)\n return make_refnode(builder, fromdocname, docname,\n declaration.get_newest_id(), contnode, displayName\n ), declaration.objectType\n\n def resolve_xref(self, env: BuildEnvironment, fromdocname: str, builder: Builder,\n typ: str, target: str, node: pending_xref, contnode: Element\n ) -> Element:\n return self._resolve_xref_inner(env, fromdocname, builder, typ,\n target, node, contnode)[0]\n\n def resolve_any_xref(self, env: BuildEnvironment, fromdocname: str, builder: Builder,\n target: str, node: pending_xref, contnode: Element\n ) -> List[Tuple[str, Element]]:\n with logging.suppress_logging():\n retnode, objtype = self._resolve_xref_inner(env, fromdocname, builder,\n 'any', target, node, contnode)\n if retnode:\n if objtype == 'templateParam':\n return [('cpp:templateParam', retnode)]\n else:\n return [('cpp:' + self.role_for_objtype(objtype), retnode)]\n return []\n\n def get_objects(self) -> Iterator[Tuple[str, str, str, str, str, int]]:\n rootSymbol = self.data['root_symbol']\n for symbol in rootSymbol.get_all_symbols():\n if symbol.declaration is None:\n continue\n assert symbol.docname\n fullNestedName = symbol.get_full_nested_name()\n name = str(fullNestedName).lstrip(':')\n dispname = fullNestedName.get_display_string().lstrip(':')\n objectType = symbol.declaration.objectType\n docname = symbol.docname\n newestId = symbol.declaration.get_newest_id()\n yield (name, dispname, objectType, docname, newestId, 1)\n\n def get_full_qualified_name(self, node: Element) -> str:\n target = node.get('reftarget', None)\n if target is None:\n return None\n parentKey = node.get(\"cpp:parent_key\", None) # type: LookupKey\n if parentKey is None or len(parentKey.data) <= 0:\n return None\n\n rootSymbol = self.data['root_symbol']\n parentSymbol = rootSymbol.direct_lookup(parentKey)\n parentName = parentSymbol.get_full_nested_name()\n return '::'.join([str(parentName), target])\n\n\ndef setup(app: Sphinx) -> Dict[str, Any]:\n app.add_domain(CPPDomain)\n app.add_config_value(\"cpp_index_common_prefix\", [], 'env')\n app.add_config_value(\"cpp_id_attributes\", [], 'env')\n app.add_config_value(\"cpp_paren_attributes\", [], 'env')\n app.add_post_transform(AliasTransform)\n\n return {\n 'version': 'builtin',\n 'env_version': 2,\n 'parallel_read_safe': True,\n 'parallel_write_safe': True,\n }"},"implementation":{"kind":"string","value":" def run(self) -> List[Node]:\n \"\"\"\n On purpose this doesn't call the ObjectDescription version, but is based on it.\n Each alias signature may expand into multiple real signatures (an overload set).\n The code is therefore based on the ObjectDescription version.\n \"\"\"\n if ':' in self.name:\n self.domain, self.objtype = self.name.split(':', 1)\n else:\n self.domain, self.objtype = '', self.name\n\n node = addnodes.desc()\n node.document = self.state.document\n node['domain'] = self.domain\n # 'desctype' is a backwards compatible attribute\n node['objtype'] = node['desctype'] = self.objtype\n node['noindex'] = True\n\n self.names = [] # type: List[str]\n signatures = self.get_signatures()\n for i, sig in enumerate(signatures):\n node.append(AliasNode(sig, env=self.env))\n\n contentnode = addnodes.desc_content()\n node.append(contentnode)\n self.before_content()\n self.state.nested_parse(self.content, self.content_offset, contentnode)\n self.env.temp_data['object'] = None\n self.after_content()\n return [node]"},"start_line":{"kind":"number","value":6818,"string":"6,818"},"end_line":{"kind":"number","value":6847,"string":"6,847"},"file_content":{"kind":"string","value":"\"\"\"\n sphinx.domains.cpp\n ~~~~~~~~~~~~~~~~~~\n\n The C++ language domain.\n\n :copyright: Copyright 2007-2020 by the Sphinx team, see AUTHORS.\n :license: BSD, see LICENSE for details.\n\"\"\"\n\nimport re\nfrom typing import (\n Any, Callable, Dict, Generator, Iterator, List, Tuple, Type, TypeVar, Union\n)\n\nfrom docutils import nodes\nfrom docutils.nodes import Element, Node, TextElement, system_message\nfrom docutils.parsers.rst import directives\n\nfrom sphinx import addnodes\nfrom sphinx.addnodes import desc_signature, pending_xref\nfrom sphinx.application import Sphinx\nfrom sphinx.builders import Builder\nfrom sphinx.directives import ObjectDescription\nfrom sphinx.domains import Domain, ObjType\nfrom sphinx.environment import BuildEnvironment\nfrom sphinx.errors import NoUri\nfrom sphinx.locale import _, __\nfrom sphinx.roles import SphinxRole, XRefRole\nfrom sphinx.transforms import SphinxTransform\nfrom sphinx.transforms.post_transforms import ReferencesResolver\nfrom sphinx.util import logging\nfrom sphinx.util.cfamily import (\n NoOldIdError, ASTBaseBase, ASTAttribute, verify_description_mode, StringifyTransform,\n BaseParser, DefinitionError, UnsupportedMultiCharacterCharLiteral,\n identifier_re, anon_identifier_re, integer_literal_re, octal_literal_re,\n hex_literal_re, binary_literal_re, float_literal_re,\n char_literal_re\n)\nfrom sphinx.util.docfields import Field, GroupedField\nfrom sphinx.util.docutils import SphinxDirective\nfrom sphinx.util.nodes import make_refnode\n\n\nlogger = logging.getLogger(__name__)\nT = TypeVar('T')\n\n\"\"\"\n Important note on ids\n ----------------------------------------------------------------------------\n\n Multiple id generation schemes are used due to backwards compatibility.\n - v1: 1.2.3 <= version < 1.3\n The style used before the rewrite.\n It is not the actual old code, but a replication of the behaviour.\n - v2: 1.3 <= version < now\n Standardised mangling scheme from\n https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling\n though not completely implemented.\n All versions are generated and attached to elements. The newest is used for\n the index. All of the versions should work as permalinks.\n\n\n Signature Nodes and Tagnames\n ----------------------------------------------------------------------------\n\n Each signature is in a desc_signature node, where all children are\n desc_signature_line nodes. Each of these lines will have the attribute\n 'sphinx_line_type' set to one of the following (prioritized):\n - 'declarator', if the line contains the name of the declared object.\n - 'templateParams', if the line starts a template parameter list,\n - 'templateParams', if the line has template parameters\n Note: such lines might get a new tag in the future.\n - 'templateIntroduction, if the line is on the form 'conceptName{...}'\n No other desc_signature nodes should exist (so far).\n\n\n Grammar\n ----------------------------------------------------------------------------\n\n See https://www.nongnu.org/hcb/ for the grammar,\n and https://github.com/cplusplus/draft/blob/master/source/grammar.tex,\n and https://github.com/cplusplus/concepts-ts\n for the newest grammar.\n\n common grammar things:\n template-declaration ->\n \"template\" \"<\" template-parameter-list \">\" declaration\n template-parameter-list ->\n template-parameter\n | template-parameter-list \",\" template-parameter\n template-parameter ->\n type-parameter\n | parameter-declaration # i.e., same as a function argument\n\n type-parameter ->\n \"class\" \"...\"[opt] identifier[opt]\n | \"class\" identifier[opt] \"=\" type-id\n | \"typename\" \"...\"[opt] identifier[opt]\n | \"typename\" identifier[opt] \"=\" type-id\n | \"template\" \"<\" template-parameter-list \">\"\n \"class\" \"...\"[opt] identifier[opt]\n | \"template\" \"<\" template-parameter-list \">\"\n \"class\" identifier[opt] \"=\" id-expression\n # also, from C++17 we can have \"typename\" in template templates\n templateDeclPrefix ->\n \"template\" \"<\" template-parameter-list \">\"\n\n simple-declaration ->\n attribute-specifier-seq[opt] decl-specifier-seq[opt]\n init-declarator-list[opt] ;\n # Drop the semi-colon. For now: drop the attributes (TODO).\n # Use at most 1 init-declarator.\n -> decl-specifier-seq init-declarator\n -> decl-specifier-seq declarator initializer\n\n decl-specifier ->\n storage-class-specifier ->\n ( \"static\" (only for member_object and function_object)\n | \"extern\" (only for member_object and function_object)\n | \"register\"\n )\n thread_local[opt] (only for member_object)\n (it can also appear before the others)\n\n | type-specifier -> trailing-type-specifier\n | function-specifier -> \"inline\" | \"virtual\" | \"explicit\" (only\n for function_object)\n | \"friend\" (only for function_object)\n | \"constexpr\" (only for member_object and function_object)\n trailing-type-specifier ->\n simple-type-specifier\n | elaborated-type-specifier\n | typename-specifier\n | cv-qualifier -> \"const\" | \"volatile\"\n stricter grammar for decl-specifier-seq (with everything, each object\n uses a subset):\n visibility storage-class-specifier function-specifier \"friend\"\n \"constexpr\" \"volatile\" \"const\" trailing-type-specifier\n # where trailing-type-specifier can no be cv-qualifier\n # Inside e.g., template paramters a strict subset is used\n # (see type-specifier-seq)\n trailing-type-specifier ->\n simple-type-specifier ->\n ::[opt] nested-name-specifier[opt] type-name\n | ::[opt] nested-name-specifier \"template\" simple-template-id\n | \"char\" | \"bool\" | ect.\n | decltype-specifier\n | elaborated-type-specifier ->\n class-key attribute-specifier-seq[opt] ::[opt]\n nested-name-specifier[opt] identifier\n | class-key ::[opt] nested-name-specifier[opt] template[opt]\n simple-template-id\n | \"enum\" ::[opt] nested-name-specifier[opt] identifier\n | typename-specifier ->\n \"typename\" ::[opt] nested-name-specifier identifier\n | \"typename\" ::[opt] nested-name-specifier template[opt]\n simple-template-id\n class-key -> \"class\" | \"struct\" | \"union\"\n type-name ->* identifier | simple-template-id\n # ignoring attributes and decltype, and then some left-factoring\n trailing-type-specifier ->\n rest-of-trailing\n (\"class\" | \"struct\" | \"union\" | \"typename\") rest-of-trailing\n build-in -> \"char\" | \"bool\" | ect.\n decltype-specifier\n rest-of-trailing -> (with some simplification)\n \"::\"[opt] list-of-elements-separated-by-::\n element ->\n \"template\"[opt] identifier (\"<\" template-argument-list \">\")[opt]\n template-argument-list ->\n template-argument \"...\"[opt]\n | template-argument-list \",\" template-argument \"...\"[opt]\n template-argument ->\n constant-expression\n | type-specifier-seq abstract-declarator\n | id-expression\n\n\n declarator ->\n ptr-declarator\n | noptr-declarator parameters-and-qualifiers trailing-return-type\n (TODO: for now we don't support trailing-eturn-type)\n ptr-declarator ->\n noptr-declarator\n | ptr-operator ptr-declarator\n noptr-declarator ->\n declarator-id attribute-specifier-seq[opt] ->\n \"...\"[opt] id-expression\n | rest-of-trailing\n | noptr-declarator parameters-and-qualifiers\n | noptr-declarator \"[\" constant-expression[opt] \"]\"\n attribute-specifier-seq[opt]\n | \"(\" ptr-declarator \")\"\n ptr-operator ->\n \"*\" attribute-specifier-seq[opt] cv-qualifier-seq[opt]\n | \"& attribute-specifier-seq[opt]\n | \"&&\" attribute-specifier-seq[opt]\n | \"::\"[opt] nested-name-specifier \"*\" attribute-specifier-seq[opt]\n cv-qualifier-seq[opt]\n # function_object must use a parameters-and-qualifiers, the others may\n # use it (e.g., function poitners)\n parameters-and-qualifiers ->\n \"(\" parameter-clause \")\" attribute-specifier-seq[opt]\n cv-qualifier-seq[opt] ref-qualifier[opt]\n exception-specification[opt]\n ref-qualifier -> \"&\" | \"&&\"\n exception-specification ->\n \"noexcept\" (\"(\" constant-expression \")\")[opt]\n \"throw\" (\"(\" type-id-list \")\")[opt]\n # TODO: we don't implement attributes\n # member functions can have initializers, but we fold them into here\n memberFunctionInit -> \"=\" \"0\"\n # (note: only \"0\" is allowed as the value, according to the standard,\n # right?)\n\n enum-head ->\n enum-key attribute-specifier-seq[opt] nested-name-specifier[opt]\n identifier enum-base[opt]\n enum-key -> \"enum\" | \"enum struct\" | \"enum class\"\n enum-base ->\n \":\" type\n enumerator-definition ->\n identifier\n | identifier \"=\" constant-expression\n\n We additionally add the possibility for specifying the visibility as the\n first thing.\n\n concept_object:\n goal:\n just a declaration of the name (for now)\n\n grammar: only a single template parameter list, and the nested name\n may not have any template argument lists\n\n \"template\" \"<\" template-parameter-list \">\"\n nested-name-specifier\n\n type_object:\n goal:\n either a single type (e.g., \"MyClass:Something_T\" or a typedef-like\n thing (e.g. \"Something Something_T\" or \"int I_arr[]\"\n grammar, single type: based on a type in a function parameter, but\n without a name:\n parameter-declaration\n -> attribute-specifier-seq[opt] decl-specifier-seq\n abstract-declarator[opt]\n # Drop the attributes\n -> decl-specifier-seq abstract-declarator[opt]\n grammar, typedef-like: no initilizer\n decl-specifier-seq declarator\n Can start with a templateDeclPrefix.\n\n member_object:\n goal: as a type_object which must have a declarator, and optionally\n with a initializer\n grammar:\n decl-specifier-seq declarator initializer\n Can start with a templateDeclPrefix.\n\n function_object:\n goal: a function declaration, TODO: what about templates? for now: skip\n grammar: no initializer\n decl-specifier-seq declarator\n Can start with a templateDeclPrefix.\n\n class_object:\n goal: a class declaration, but with specification of a base class\n grammar:\n nested-name \"final\"[opt] (\":\" base-specifier-list)[opt]\n base-specifier-list ->\n base-specifier \"...\"[opt]\n | base-specifier-list, base-specifier \"...\"[opt]\n base-specifier ->\n base-type-specifier\n | \"virtual\" access-spe\"cifier[opt] base-type-specifier\n | access-specifier[opt] \"virtual\"[opt] base-type-specifier\n Can start with a templateDeclPrefix.\n\n enum_object:\n goal: an unscoped enum or a scoped enum, optionally with the underlying\n type specified\n grammar:\n (\"class\" | \"struct\")[opt] visibility[opt] nested-name (\":\" type)[opt]\n enumerator_object:\n goal: an element in a scoped or unscoped enum. The name should be\n injected according to the scopedness.\n grammar:\n nested-name (\"=\" constant-expression)\n\n namespace_object:\n goal: a directive to put all following declarations in a specific scope\n grammar:\n nested-name\n\"\"\"\n\n_string_re = re.compile(r\"[LuU8]?('([^'\\\\]*(?:\\\\.[^'\\\\]*)*)'\"\n r'|\"([^\"\\\\]*(?:\\\\.[^\"\\\\]*)*)\")', re.S)\n_visibility_re = re.compile(r'\\b(public|private|protected)\\b')\n_operator_re = re.compile(r'''(?x)\n \\[\\s*\\]\n | \\(\\s*\\)\n | \\+\\+ | --\n | ->\\*? | \\,\n | (<<|>>)=? | && | \\|\\|\n | [!<>=/*%+|&^~-]=?\n | (\\b(and|and_eq|bitand|bitor|compl|not|not_eq|or|or_eq|xor|xor_eq)\\b)\n''')\n_fold_operator_re = re.compile(r'''(?x)\n ->\\* | \\.\\* | \\,\n | (<<|>>)=? | && | \\|\\|\n | !=\n | [<>=/*%+|&^~-]=?\n''')\n# see https://en.cppreference.com/w/cpp/keyword\n_keywords = [\n 'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor',\n 'bool', 'break', 'case', 'catch', 'char', 'char16_t', 'char32_t', 'class',\n 'compl', 'concept', 'const', 'constexpr', 'const_cast', 'continue',\n 'decltype', 'default', 'delete', 'do', 'double', 'dynamic_cast', 'else',\n 'enum', 'explicit', 'export', 'extern', 'false', 'float', 'for', 'friend',\n 'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new',\n 'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq',\n 'private', 'protected', 'public', 'register', 'reinterpret_cast',\n 'requires', 'return', 'short', 'signed', 'sizeof', 'static',\n 'static_assert', 'static_cast', 'struct', 'switch', 'template', 'this',\n 'thread_local', 'throw', 'true', 'try', 'typedef', 'typeid', 'typename',\n 'union', 'unsigned', 'using', 'virtual', 'void', 'volatile', 'wchar_t',\n 'while', 'xor', 'xor_eq'\n]\n\n_max_id = 4\n_id_prefix = [None, '', '_CPPv2', '_CPPv3', '_CPPv4']\n# Ids are used in lookup keys which are used across pickled files,\n# so when _max_id changes, make sure to update the ENV_VERSION.\n\n# ------------------------------------------------------------------------------\n# Id v1 constants\n# ------------------------------------------------------------------------------\n\n_id_fundamental_v1 = {\n 'char': 'c',\n 'signed char': 'c',\n 'unsigned char': 'C',\n 'int': 'i',\n 'signed int': 'i',\n 'unsigned int': 'U',\n 'long': 'l',\n 'signed long': 'l',\n 'unsigned long': 'L',\n 'bool': 'b'\n}\n_id_shorthands_v1 = {\n 'std::string': 'ss',\n 'std::ostream': 'os',\n 'std::istream': 'is',\n 'std::iostream': 'ios',\n 'std::vector': 'v',\n 'std::map': 'm'\n}\n_id_operator_v1 = {\n 'new': 'new-operator',\n 'new[]': 'new-array-operator',\n 'delete': 'delete-operator',\n 'delete[]': 'delete-array-operator',\n # the arguments will make the difference between unary and binary\n # '+(unary)' : 'ps',\n # '-(unary)' : 'ng',\n # '&(unary)' : 'ad',\n # '*(unary)' : 'de',\n '~': 'inv-operator',\n '+': 'add-operator',\n '-': 'sub-operator',\n '*': 'mul-operator',\n '/': 'div-operator',\n '%': 'mod-operator',\n '&': 'and-operator',\n '|': 'or-operator',\n '^': 'xor-operator',\n '=': 'assign-operator',\n '+=': 'add-assign-operator',\n '-=': 'sub-assign-operator',\n '*=': 'mul-assign-operator',\n '/=': 'div-assign-operator',\n '%=': 'mod-assign-operator',\n '&=': 'and-assign-operator',\n '|=': 'or-assign-operator',\n '^=': 'xor-assign-operator',\n '<<': 'lshift-operator',\n '>>': 'rshift-operator',\n '<<=': 'lshift-assign-operator',\n '>>=': 'rshift-assign-operator',\n '==': 'eq-operator',\n '!=': 'neq-operator',\n '<': 'lt-operator',\n '>': 'gt-operator',\n '<=': 'lte-operator',\n '>=': 'gte-operator',\n '!': 'not-operator',\n '&&': 'sand-operator',\n '||': 'sor-operator',\n '++': 'inc-operator',\n '--': 'dec-operator',\n ',': 'comma-operator',\n '->*': 'pointer-by-pointer-operator',\n '->': 'pointer-operator',\n '()': 'call-operator',\n '[]': 'subscript-operator'\n}\n\n# ------------------------------------------------------------------------------\n# Id v > 1 constants\n# ------------------------------------------------------------------------------\n\n_id_fundamental_v2 = {\n # not all of these are actually parsed as fundamental types, TODO: do that\n 'void': 'v',\n 'bool': 'b',\n 'char': 'c',\n 'signed char': 'a',\n 'unsigned char': 'h',\n 'wchar_t': 'w',\n 'char32_t': 'Di',\n 'char16_t': 'Ds',\n 'short': 's',\n 'short int': 's',\n 'signed short': 's',\n 'signed short int': 's',\n 'unsigned short': 't',\n 'unsigned short int': 't',\n 'int': 'i',\n 'signed': 'i',\n 'signed int': 'i',\n 'unsigned': 'j',\n 'unsigned int': 'j',\n 'long': 'l',\n 'long int': 'l',\n 'signed long': 'l',\n 'signed long int': 'l',\n 'unsigned long': 'm',\n 'unsigned long int': 'm',\n 'long long': 'x',\n 'long long int': 'x',\n 'signed long long': 'x',\n 'signed long long int': 'x',\n 'unsigned long long': 'y',\n 'unsigned long long int': 'y',\n 'float': 'f',\n 'double': 'd',\n 'long double': 'e',\n 'auto': 'Da',\n 'decltype(auto)': 'Dc',\n 'std::nullptr_t': 'Dn'\n}\n_id_operator_v2 = {\n 'new': 'nw',\n 'new[]': 'na',\n 'delete': 'dl',\n 'delete[]': 'da',\n # the arguments will make the difference between unary and binary\n # in operator definitions\n # '+(unary)' : 'ps',\n # '-(unary)' : 'ng',\n # '&(unary)' : 'ad',\n # '*(unary)' : 'de',\n '~': 'co', 'compl': 'co',\n '+': 'pl',\n '-': 'mi',\n '*': 'ml',\n '/': 'dv',\n '%': 'rm',\n '&': 'an', 'bitand': 'an',\n '|': 'or', 'bitor': 'or',\n '^': 'eo', 'xor': 'eo',\n '=': 'aS',\n '+=': 'pL',\n '-=': 'mI',\n '*=': 'mL',\n '/=': 'dV',\n '%=': 'rM',\n '&=': 'aN', 'and_eq': 'aN',\n '|=': 'oR', 'or_eq': 'oR',\n '^=': 'eO', 'xor_eq': 'eO',\n '<<': 'ls',\n '>>': 'rs',\n '<<=': 'lS',\n '>>=': 'rS',\n '==': 'eq',\n '!=': 'ne', 'not_eq': 'ne',\n '<': 'lt',\n '>': 'gt',\n '<=': 'le',\n '>=': 'ge',\n '!': 'nt', 'not': 'nt',\n '&&': 'aa', 'and': 'aa',\n '||': 'oo', 'or': 'oo',\n '++': 'pp',\n '--': 'mm',\n ',': 'cm',\n '->*': 'pm',\n '->': 'pt',\n '()': 'cl',\n '[]': 'ix',\n '.*': 'ds' # this one is not overloadable, but we need it for expressions\n}\n_id_operator_unary_v2 = {\n '++': 'pp_',\n '--': 'mm_',\n '*': 'de',\n '&': 'ad',\n '+': 'ps',\n '-': 'ng',\n '!': 'nt', 'not': 'nt',\n '~': 'co', 'compl': 'co'\n}\n_id_char_from_prefix = {\n None: 'c', 'u8': 'c',\n 'u': 'Ds', 'U': 'Di', 'L': 'w'\n} # type: Dict[Any, str]\n# these are ordered by preceedence\n_expression_bin_ops = [\n ['||', 'or'],\n ['&&', 'and'],\n ['|', 'bitor'],\n ['^', 'xor'],\n ['&', 'bitand'],\n ['==', '!=', 'not_eq'],\n ['<=', '>=', '<', '>'],\n ['<<', '>>'],\n ['+', '-'],\n ['*', '/', '%'],\n ['.*', '->*']\n]\n_expression_unary_ops = [\"++\", \"--\", \"*\", \"&\", \"+\", \"-\", \"!\", \"not\", \"~\", \"compl\"]\n_expression_assignment_ops = [\"=\", \"*=\", \"/=\", \"%=\", \"+=\", \"-=\",\n \">>=\", \"<<=\", \"&=\", \"and_eq\", \"^=\", \"|=\", \"xor_eq\", \"or_eq\"]\n_id_explicit_cast = {\n 'dynamic_cast': 'dc',\n 'static_cast': 'sc',\n 'const_cast': 'cc',\n 'reinterpret_cast': 'rc'\n}\n\n\nclass _DuplicateSymbolError(Exception):\n def __init__(self, symbol: \"Symbol\", declaration: \"ASTDeclaration\") -> None:\n assert symbol\n assert declaration\n self.symbol = symbol\n self.declaration = declaration\n\n def __str__(self) -> str:\n return \"Internal C++ duplicate symbol error:\\n%s\" % self.symbol.dump(0)\n\n\nclass ASTBase(ASTBaseBase):\n pass\n\n\n# Names\n################################################################################\n\nclass ASTIdentifier(ASTBase):\n def __init__(self, identifier: str) -> None:\n assert identifier is not None\n assert len(identifier) != 0\n self.identifier = identifier\n\n def is_anon(self) -> bool:\n return self.identifier[0] == '@'\n\n def get_id(self, version: int) -> str:\n if self.is_anon() and version < 3:\n raise NoOldIdError()\n if version == 1:\n if self.identifier == 'size_t':\n return 's'\n else:\n return self.identifier\n if self.identifier == \"std\":\n return 'St'\n elif self.identifier[0] == \"~\":\n # a destructor, just use an arbitrary version of dtors\n return 'D0'\n else:\n if self.is_anon():\n return 'Ut%d_%s' % (len(self.identifier) - 1, self.identifier[1:])\n else:\n return str(len(self.identifier)) + self.identifier\n\n # and this is where we finally make a difference between __str__ and the display string\n\n def __str__(self) -> str:\n return self.identifier\n\n def get_display_string(self) -> str:\n return \"[anonymous]\" if self.is_anon() else self.identifier\n\n def describe_signature(self, signode: TextElement, mode: str, env: \"BuildEnvironment\",\n prefix: str, templateArgs: str, symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if mode == 'markType':\n targetText = prefix + self.identifier + templateArgs\n pnode = addnodes.pending_xref('', refdomain='cpp',\n reftype='identifier',\n reftarget=targetText, modname=None,\n classname=None)\n key = symbol.get_lookup_key()\n pnode['cpp:parent_key'] = key\n if self.is_anon():\n pnode += nodes.strong(text=\"[anonymous]\")\n else:\n pnode += nodes.Text(self.identifier)\n signode += pnode\n elif mode == 'lastIsName':\n if self.is_anon():\n signode += nodes.strong(text=\"[anonymous]\")\n else:\n signode += addnodes.desc_name(self.identifier, self.identifier)\n elif mode == 'noneIsName':\n if self.is_anon():\n signode += nodes.strong(text=\"[anonymous]\")\n else:\n signode += nodes.Text(self.identifier)\n else:\n raise Exception('Unknown description mode: %s' % mode)\n\n\nclass ASTNestedNameElement(ASTBase):\n def __init__(self, identOrOp: Union[ASTIdentifier, \"ASTOperator\"],\n templateArgs: \"ASTTemplateArgs\") -> None:\n self.identOrOp = identOrOp\n self.templateArgs = templateArgs\n\n def is_operator(self) -> bool:\n return False\n\n def get_id(self, version: int) -> str:\n res = self.identOrOp.get_id(version)\n if self.templateArgs:\n res += self.templateArgs.get_id(version)\n return res\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = transform(self.identOrOp)\n if self.templateArgs:\n res += transform(self.templateArgs)\n return res\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", prefix: str, symbol: \"Symbol\") -> None:\n tArgs = str(self.templateArgs) if self.templateArgs is not None else ''\n self.identOrOp.describe_signature(signode, mode, env, prefix, tArgs, symbol)\n if self.templateArgs is not None:\n self.templateArgs.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTNestedName(ASTBase):\n def __init__(self, names: List[ASTNestedNameElement],\n templates: List[bool], rooted: bool) -> None:\n assert len(names) > 0\n self.names = names\n self.templates = templates\n assert len(self.names) == len(self.templates)\n self.rooted = rooted\n\n @property\n def name(self) -> \"ASTNestedName\":\n return self\n\n def num_templates(self) -> int:\n count = 0\n for n in self.names:\n if n.is_operator():\n continue\n if n.templateArgs:\n count += 1\n return count\n\n def get_id(self, version: int, modifiers: str = '') -> str:\n if version == 1:\n tt = str(self)\n if tt in _id_shorthands_v1:\n return _id_shorthands_v1[tt]\n else:\n return '::'.join(n.get_id(version) for n in self.names)\n\n res = []\n if len(self.names) > 1 or len(modifiers) > 0:\n res.append('N')\n res.append(modifiers)\n for n in self.names:\n res.append(n.get_id(version))\n if len(self.names) > 1 or len(modifiers) > 0:\n res.append('E')\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.rooted:\n res.append('')\n for i in range(len(self.names)):\n n = self.names[i]\n t = self.templates[i]\n if t:\n res.append(\"template \" + transform(n))\n else:\n res.append(transform(n))\n return '::'.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n # just print the name part, with template args, not template params\n if mode == 'noneIsName':\n signode += nodes.Text(str(self))\n elif mode == 'param':\n name = str(self)\n signode += nodes.emphasis(name, name)\n elif mode == 'markType' or mode == 'lastIsName' or mode == 'markName':\n # Each element should be a pending xref targeting the complete\n # prefix. however, only the identifier part should be a link, such\n # that template args can be a link as well.\n # For 'lastIsName' we should also prepend template parameter lists.\n templateParams = [] # type: List[Any]\n if mode == 'lastIsName':\n assert symbol is not None\n if symbol.declaration.templatePrefix is not None:\n templateParams = symbol.declaration.templatePrefix.templates\n iTemplateParams = 0\n templateParamsPrefix = ''\n prefix = ''\n first = True\n names = self.names[:-1] if mode == 'lastIsName' else self.names\n # If lastIsName, then wrap all of the prefix in a desc_addname,\n # else append directly to signode.\n # NOTE: Breathe relies on the prefix being in the desc_addname node,\n # so it can remove it in inner declarations.\n dest = signode\n if mode == 'lastIsName':\n dest = addnodes.desc_addname()\n for i in range(len(names)):\n nne = names[i]\n template = self.templates[i]\n if not first:\n dest += nodes.Text('::')\n prefix += '::'\n if template:\n dest += nodes.Text(\"template \")\n first = False\n txt_nne = str(nne)\n if txt_nne != '':\n if nne.templateArgs and iTemplateParams < len(templateParams):\n templateParamsPrefix += str(templateParams[iTemplateParams])\n iTemplateParams += 1\n nne.describe_signature(dest, 'markType',\n env, templateParamsPrefix + prefix, symbol)\n prefix += txt_nne\n if mode == 'lastIsName':\n if len(self.names) > 1:\n dest += addnodes.desc_addname('::', '::')\n signode += dest\n if self.templates[-1]:\n signode += nodes.Text(\"template \")\n self.names[-1].describe_signature(signode, mode, env, '', symbol)\n else:\n raise Exception('Unknown description mode: %s' % mode)\n\n\n################################################################################\n# Expressions\n################################################################################\n\nclass ASTExpression(ASTBase):\n def get_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n raise NotImplementedError(repr(self))\n\n\n# Primary expressions\n################################################################################\n\nclass ASTLiteral(ASTExpression):\n pass\n\n\nclass ASTPointerLiteral(ASTLiteral):\n def _stringify(self, transform: StringifyTransform) -> str:\n return 'nullptr'\n\n def get_id(self, version: int) -> str:\n return 'LDnE'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('nullptr'))\n\n\nclass ASTBooleanLiteral(ASTLiteral):\n def __init__(self, value: bool) -> None:\n self.value = value\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.value:\n return 'true'\n else:\n return 'false'\n\n def get_id(self, version: int) -> str:\n if self.value:\n return 'L1E'\n else:\n return 'L0E'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text(str(self)))\n\n\nclass ASTNumberLiteral(ASTLiteral):\n def __init__(self, data: str) -> None:\n self.data = data\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return self.data\n\n def get_id(self, version: int) -> str:\n return \"L%sE\" % self.data\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n txt = str(self)\n signode.append(nodes.Text(txt, txt))\n\n\nclass ASTStringLiteral(ASTLiteral):\n def __init__(self, data: str) -> None:\n self.data = data\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return self.data\n\n def get_id(self, version: int) -> str:\n # note: the length is not really correct with escaping\n return \"LA%d_KcE\" % (len(self.data) - 2)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n txt = str(self)\n signode.append(nodes.Text(txt, txt))\n\n\nclass ASTCharLiteral(ASTLiteral):\n def __init__(self, prefix: str, data: str) -> None:\n self.prefix = prefix # may be None when no prefix\n self.data = data\n assert prefix in _id_char_from_prefix\n self.type = _id_char_from_prefix[prefix]\n decoded = data.encode().decode('unicode-escape')\n if len(decoded) == 1:\n self.value = ord(decoded)\n else:\n raise UnsupportedMultiCharacterCharLiteral(decoded)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.prefix is None:\n return \"'\" + self.data + \"'\"\n else:\n return self.prefix + \"'\" + self.data + \"'\"\n\n def get_id(self, version: int) -> str:\n return self.type + str(self.value)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n txt = str(self)\n signode.append(nodes.Text(txt, txt))\n\n\nclass ASTThisLiteral(ASTExpression):\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"this\"\n\n def get_id(self, version: int) -> str:\n return \"fpT\"\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text(\"this\"))\n\n\nclass ASTFoldExpr(ASTExpression):\n def __init__(self, leftExpr: ASTExpression,\n op: str, rightExpr: ASTExpression) -> None:\n assert leftExpr is not None or rightExpr is not None\n self.leftExpr = leftExpr\n self.op = op\n self.rightExpr = rightExpr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ['(']\n if self.leftExpr:\n res.append(transform(self.leftExpr))\n res.append(' ')\n res.append(transform(self.op))\n res.append(' ')\n res.append('...')\n if self.rightExpr:\n res.append(' ')\n res.append(transform(self.op))\n res.append(' ')\n res.append(transform(self.rightExpr))\n res.append(')')\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n assert version >= 3\n if version == 3:\n return str(self)\n # https://github.com/itanium-cxx-abi/cxx-abi/pull/67\n res = []\n if self.leftExpr is None: # (... op expr)\n res.append('fl')\n elif self.rightExpr is None: # (expr op ...)\n res.append('fr')\n else: # (expr op ... op expr)\n # we don't check where the parameter pack is,\n # we just always call this a binary left fold\n res.append('fL')\n res.append(_id_operator_v2[self.op])\n if self.leftExpr:\n res.append(self.leftExpr.get_id(version))\n if self.rightExpr:\n res.append(self.rightExpr.get_id(version))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('('))\n if self.leftExpr:\n self.leftExpr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(' '))\n signode.append(nodes.Text(self.op))\n signode.append(nodes.Text(' '))\n signode.append(nodes.Text('...'))\n if self.rightExpr:\n signode.append(nodes.Text(' '))\n signode.append(nodes.Text(self.op))\n signode.append(nodes.Text(' '))\n self.rightExpr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTParenExpr(ASTExpression):\n def __init__(self, expr: ASTExpression):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return '(' + transform(self.expr) + ')'\n\n def get_id(self, version: int) -> str:\n return self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('(', '('))\n self.expr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')', ')'))\n\n\nclass ASTIdExpression(ASTExpression):\n def __init__(self, name: ASTNestedName):\n # note: this class is basically to cast a nested name as an expression\n self.name = name\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.name)\n\n def get_id(self, version: int) -> str:\n return self.name.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.name.describe_signature(signode, mode, env, symbol)\n\n\n# Postfix expressions\n################################################################################\n\nclass ASTPostfixOp(ASTBase):\n def get_id(self, idPrefix: str, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n raise NotImplementedError(repr(self))\n\n\nclass ASTPostfixArray(ASTPostfixOp):\n def __init__(self, expr: ASTExpression):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return '[' + transform(self.expr) + ']'\n\n def get_id(self, idPrefix: str, version: int) -> str:\n return 'ix' + idPrefix + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('['))\n self.expr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(']'))\n\n\nclass ASTPostfixMember(ASTPostfixOp):\n def __init__(self, name: ASTNestedName):\n self.name = name\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return '.' + transform(self.name)\n\n def get_id(self, idPrefix: str, version: int) -> str:\n return 'dt' + idPrefix + self.name.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('.'))\n self.name.describe_signature(signode, 'noneIsName', env, symbol)\n\n\nclass ASTPostfixMemberOfPointer(ASTPostfixOp):\n def __init__(self, name: ASTNestedName):\n self.name = name\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return '->' + transform(self.name)\n\n def get_id(self, idPrefix: str, version: int) -> str:\n return 'pt' + idPrefix + self.name.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('->'))\n self.name.describe_signature(signode, 'noneIsName', env, symbol)\n\n\nclass ASTPostfixInc(ASTPostfixOp):\n def _stringify(self, transform: StringifyTransform) -> str:\n return '++'\n\n def get_id(self, idPrefix: str, version: int) -> str:\n return 'pp' + idPrefix\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('++'))\n\n\nclass ASTPostfixDec(ASTPostfixOp):\n def _stringify(self, transform: StringifyTransform) -> str:\n return '--'\n\n def get_id(self, idPrefix: str, version: int) -> str:\n return 'mm' + idPrefix\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('--'))\n\n\nclass ASTPostfixCallExpr(ASTPostfixOp):\n def __init__(self, lst: Union[\"ASTParenExprList\", \"ASTBracedInitList\"]) -> None:\n self.lst = lst\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.lst)\n\n def get_id(self, idPrefix: str, version: int) -> str:\n res = ['cl', idPrefix]\n for e in self.lst.exprs:\n res.append(e.get_id(version))\n res.append('E')\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.lst.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTPostfixExpr(ASTExpression):\n def __init__(self, prefix: \"ASTType\", postFixes: List[ASTPostfixOp]):\n self.prefix = prefix\n self.postFixes = postFixes\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = [transform(self.prefix)]\n for p in self.postFixes:\n res.append(transform(p))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n id = self.prefix.get_id(version)\n for p in self.postFixes:\n id = p.get_id(id, version)\n return id\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.prefix.describe_signature(signode, mode, env, symbol)\n for p in self.postFixes:\n p.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTExplicitCast(ASTExpression):\n def __init__(self, cast: str, typ: \"ASTType\", expr: ASTExpression):\n assert cast in _id_explicit_cast\n self.cast = cast\n self.typ = typ\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = [self.cast]\n res.append('<')\n res.append(transform(self.typ))\n res.append('>(')\n res.append(transform(self.expr))\n res.append(')')\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n return (_id_explicit_cast[self.cast] +\n self.typ.get_id(version) +\n self.expr.get_id(version))\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text(self.cast))\n signode.append(nodes.Text('<'))\n self.typ.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text('>'))\n signode.append(nodes.Text('('))\n self.expr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTTypeId(ASTExpression):\n def __init__(self, typeOrExpr: Union[\"ASTType\", ASTExpression], isType: bool):\n self.typeOrExpr = typeOrExpr\n self.isType = isType\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return 'typeid(' + transform(self.typeOrExpr) + ')'\n\n def get_id(self, version: int) -> str:\n prefix = 'ti' if self.isType else 'te'\n return prefix + self.typeOrExpr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('typeid'))\n signode.append(nodes.Text('('))\n self.typeOrExpr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\n# Unary expressions\n################################################################################\n\nclass ASTUnaryOpExpr(ASTExpression):\n def __init__(self, op: str, expr: ASTExpression):\n self.op = op\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.op[0] in 'cn':\n return transform(self.op) + \" \" + transform(self.expr)\n else:\n return transform(self.op) + transform(self.expr)\n\n def get_id(self, version: int) -> str:\n return _id_operator_unary_v2[self.op] + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text(self.op))\n if self.op[0] in 'cn':\n signode.append(nodes.Text(' '))\n self.expr.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTSizeofParamPack(ASTExpression):\n def __init__(self, identifier: ASTIdentifier):\n self.identifier = identifier\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"sizeof...(\" + transform(self.identifier) + \")\"\n\n def get_id(self, version: int) -> str:\n return 'sZ' + self.identifier.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('sizeof...('))\n self.identifier.describe_signature(signode, mode, env,\n symbol=symbol, prefix=\"\", templateArgs=\"\")\n signode.append(nodes.Text(')'))\n\n\nclass ASTSizeofType(ASTExpression):\n def __init__(self, typ: \"ASTType\"):\n self.typ = typ\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"sizeof(\" + transform(self.typ) + \")\"\n\n def get_id(self, version: int) -> str:\n return 'st' + self.typ.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('sizeof('))\n self.typ.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTSizeofExpr(ASTExpression):\n def __init__(self, expr: ASTExpression):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"sizeof \" + transform(self.expr)\n\n def get_id(self, version: int) -> str:\n return 'sz' + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('sizeof '))\n self.expr.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTAlignofExpr(ASTExpression):\n def __init__(self, typ: \"ASTType\"):\n self.typ = typ\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"alignof(\" + transform(self.typ) + \")\"\n\n def get_id(self, version: int) -> str:\n return 'at' + self.typ.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('alignof('))\n self.typ.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTNoexceptExpr(ASTExpression):\n def __init__(self, expr: ASTExpression):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return \"noexcept(\" + transform(self.expr) + \")\"\n\n def get_id(self, version: int) -> str:\n return 'nx' + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('noexcept('))\n self.expr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTNewExpr(ASTExpression):\n def __init__(self, rooted: bool, isNewTypeId: bool, typ: \"ASTType\",\n initList: Union[\"ASTParenExprList\", \"ASTBracedInitList\"]) -> None:\n self.rooted = rooted\n self.isNewTypeId = isNewTypeId\n self.typ = typ\n self.initList = initList\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.rooted:\n res.append('::')\n res.append('new ')\n # TODO: placement\n if self.isNewTypeId:\n res.append(transform(self.typ))\n else:\n assert False\n if self.initList is not None:\n res.append(transform(self.initList))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n # the array part will be in the type mangling, so na is not used\n res = ['nw']\n # TODO: placement\n res.append('_')\n res.append(self.typ.get_id(version))\n if self.initList is not None:\n res.append(self.initList.get_id(version))\n else:\n res.append('E')\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n if self.rooted:\n signode.append(nodes.Text('::'))\n signode.append(nodes.Text('new '))\n # TODO: placement\n if self.isNewTypeId:\n self.typ.describe_signature(signode, mode, env, symbol)\n else:\n assert False\n if self.initList is not None:\n self.initList.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeleteExpr(ASTExpression):\n def __init__(self, rooted: bool, array: bool, expr: ASTExpression):\n self.rooted = rooted\n self.array = array\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.rooted:\n res.append('::')\n res.append('delete ')\n if self.array:\n res.append('[] ')\n res.append(transform(self.expr))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n if self.array:\n id = \"da\"\n else:\n id = \"dl\"\n return id + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n if self.rooted:\n signode.append(nodes.Text('::'))\n signode.append(nodes.Text('delete '))\n if self.array:\n signode.append(nodes.Text('[] '))\n self.expr.describe_signature(signode, mode, env, symbol)\n\n\n# Other expressions\n################################################################################\n\nclass ASTCastExpr(ASTExpression):\n def __init__(self, typ: \"ASTType\", expr: ASTExpression):\n self.typ = typ\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ['(']\n res.append(transform(self.typ))\n res.append(')')\n res.append(transform(self.expr))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n return 'cv' + self.typ.get_id(version) + self.expr.get_id(version)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('('))\n self.typ.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n self.expr.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTBinOpExpr(ASTExpression):\n def __init__(self, exprs: List[ASTExpression], ops: List[str]):\n assert len(exprs) > 0\n assert len(exprs) == len(ops) + 1\n self.exprs = exprs\n self.ops = ops\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.exprs[0]))\n for i in range(1, len(self.exprs)):\n res.append(' ')\n res.append(self.ops[i - 1])\n res.append(' ')\n res.append(transform(self.exprs[i]))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n assert version >= 2\n res = []\n for i in range(len(self.ops)):\n res.append(_id_operator_v2[self.ops[i]])\n res.append(self.exprs[i].get_id(version))\n res.append(self.exprs[-1].get_id(version))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.exprs[0].describe_signature(signode, mode, env, symbol)\n for i in range(1, len(self.exprs)):\n signode.append(nodes.Text(' '))\n signode.append(nodes.Text(self.ops[i - 1]))\n signode.append(nodes.Text(' '))\n self.exprs[i].describe_signature(signode, mode, env, symbol)\n\n\nclass ASTBracedInitList(ASTBase):\n def __init__(self, exprs: List[Union[ASTExpression, \"ASTBracedInitList\"]],\n trailingComma: bool) -> None:\n self.exprs = exprs\n self.trailingComma = trailingComma\n\n def get_id(self, version: int) -> str:\n return \"il%sE\" % ''.join(e.get_id(version) for e in self.exprs)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n exprs = [transform(e) for e in self.exprs]\n trailingComma = ',' if self.trailingComma else ''\n return '{%s%s}' % (', '.join(exprs), trailingComma)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode.append(nodes.Text('{'))\n first = True\n for e in self.exprs:\n if not first:\n signode.append(nodes.Text(', '))\n else:\n first = False\n e.describe_signature(signode, mode, env, symbol)\n if self.trailingComma:\n signode.append(nodes.Text(','))\n signode.append(nodes.Text('}'))\n\n\nclass ASTAssignmentExpr(ASTExpression):\n def __init__(self, exprs: List[Union[ASTExpression, ASTBracedInitList]], ops: List[str]):\n assert len(exprs) > 0\n assert len(exprs) == len(ops) + 1\n self.exprs = exprs\n self.ops = ops\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.exprs[0]))\n for i in range(1, len(self.exprs)):\n res.append(' ')\n res.append(self.ops[i - 1])\n res.append(' ')\n res.append(transform(self.exprs[i]))\n return ''.join(res)\n\n def get_id(self, version: int) -> str:\n res = []\n for i in range(len(self.ops)):\n res.append(_id_operator_v2[self.ops[i]])\n res.append(self.exprs[i].get_id(version))\n res.append(self.exprs[-1].get_id(version))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.exprs[0].describe_signature(signode, mode, env, symbol)\n for i in range(1, len(self.exprs)):\n signode.append(nodes.Text(' '))\n signode.append(nodes.Text(self.ops[i - 1]))\n signode.append(nodes.Text(' '))\n self.exprs[i].describe_signature(signode, mode, env, symbol)\n\n\nclass ASTCommaExpr(ASTExpression):\n def __init__(self, exprs: List[ASTExpression]):\n assert len(exprs) > 0\n self.exprs = exprs\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return ', '.join(transform(e) for e in self.exprs)\n\n def get_id(self, version: int) -> str:\n id_ = _id_operator_v2[',']\n res = []\n for i in range(len(self.exprs) - 1):\n res.append(id_)\n res.append(self.exprs[i].get_id(version))\n res.append(self.exprs[-1].get_id(version))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.exprs[0].describe_signature(signode, mode, env, symbol)\n for i in range(1, len(self.exprs)):\n signode.append(nodes.Text(', '))\n self.exprs[i].describe_signature(signode, mode, env, symbol)\n\n\nclass ASTFallbackExpr(ASTExpression):\n def __init__(self, expr: str):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return self.expr\n\n def get_id(self, version: int) -> str:\n return str(self.expr)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode += nodes.Text(self.expr)\n\n\n################################################################################\n# Types\n################################################################################\n\n# Things for ASTNestedName\n################################################################################\n\nclass ASTOperator(ASTBase):\n def is_anon(self) -> bool:\n return False\n\n def is_operator(self) -> bool:\n return True\n\n def get_id(self, version: int) -> str:\n raise NotImplementedError()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", prefix: str, templateArgs: str,\n symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n identifier = str(self)\n if mode == 'lastIsName':\n signode += addnodes.desc_name(identifier, identifier)\n else:\n signode += addnodes.desc_addname(identifier, identifier)\n\n\nclass ASTOperatorBuildIn(ASTOperator):\n def __init__(self, op: str) -> None:\n self.op = op\n\n def get_id(self, version: int) -> str:\n if version == 1:\n ids = _id_operator_v1\n if self.op not in ids:\n raise NoOldIdError()\n else:\n ids = _id_operator_v2\n if self.op not in ids:\n raise Exception('Internal error: Build-in operator \"%s\" can not '\n 'be mapped to an id.' % self.op)\n return ids[self.op]\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.op in ('new', 'new[]', 'delete', 'delete[]') or self.op[0] in \"abcnox\":\n return 'operator ' + self.op\n else:\n return 'operator' + self.op\n\n\nclass ASTOperatorLiteral(ASTOperator):\n def __init__(self, identifier: ASTIdentifier) -> None:\n self.identifier = identifier\n\n def get_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError()\n else:\n return 'li' + self.identifier.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return 'operator\"\"' + transform(self.identifier)\n\n\nclass ASTOperatorType(ASTOperator):\n def __init__(self, type: \"ASTType\") -> None:\n self.type = type\n\n def get_id(self, version: int) -> str:\n if version == 1:\n return 'castto-%s-operator' % self.type.get_id(version)\n else:\n return 'cv' + self.type.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return ''.join(['operator ', transform(self.type)])\n\n def get_name_no_template(self) -> str:\n return str(self)\n\n\nclass ASTTemplateArgConstant(ASTBase):\n def __init__(self, value: ASTExpression) -> None:\n self.value = value\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.value)\n\n def get_id(self, version: int) -> str:\n if version == 1:\n return str(self).replace(' ', '-')\n if version == 2:\n return 'X' + str(self) + 'E'\n return 'X' + self.value.get_id(version) + 'E'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.value.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTemplateArgs(ASTBase):\n def __init__(self, args: List[Union[\"ASTType\", ASTTemplateArgConstant]],\n packExpansion: bool) -> None:\n assert args is not None\n self.args = args\n self.packExpansion = packExpansion\n\n def get_id(self, version: int) -> str:\n if version == 1:\n res = []\n res.append(':')\n res.append('.'.join(a.get_id(version) for a in self.args))\n res.append(':')\n return ''.join(res)\n\n res = []\n res.append('I')\n if len(self.args) > 0:\n for a in self.args[:-1]:\n res.append(a.get_id(version))\n if self.packExpansion:\n res.append('J')\n res.append(self.args[-1].get_id(version))\n if self.packExpansion:\n res.append('E')\n res.append('E')\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ', '.join(transform(a) for a in self.args)\n if self.packExpansion:\n res += '...'\n return '<' + res + '>'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode += nodes.Text('<')\n first = True\n for a in self.args:\n if not first:\n signode += nodes.Text(', ')\n first = False\n a.describe_signature(signode, 'markType', env, symbol=symbol)\n if self.packExpansion:\n signode += nodes.Text('...')\n signode += nodes.Text('>')\n\n\n# Main part of declarations\n################################################################################\n\nclass ASTTrailingTypeSpec(ASTBase):\n def get_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n raise NotImplementedError(repr(self))\n\n\nclass ASTTrailingTypeSpecFundamental(ASTTrailingTypeSpec):\n def __init__(self, name: str) -> None:\n self.name = name\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return self.name\n\n def get_id(self, version: int) -> str:\n if version == 1:\n res = []\n for a in self.name.split(' '):\n if a in _id_fundamental_v1:\n res.append(_id_fundamental_v1[a])\n else:\n res.append(a)\n return '-'.join(res)\n\n if self.name not in _id_fundamental_v2:\n raise Exception(\n 'Semi-internal error: Fundamental type \"%s\" can not be mapped '\n 'to an id. Is it a true fundamental type? If not so, the '\n 'parser should have rejected it.' % self.name)\n return _id_fundamental_v2[self.name]\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode += nodes.Text(str(self.name))\n\n\nclass ASTTrailingTypeSpecDecltypeAuto(ASTTrailingTypeSpec):\n def _stringify(self, transform: StringifyTransform) -> str:\n return 'decltype(auto)'\n\n def get_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError()\n return 'Dc'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text(str(self)))\n\n\nclass ASTTrailingTypeSpecDecltype(ASTTrailingTypeSpec):\n def __init__(self, expr: ASTExpression):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return 'decltype(' + transform(self.expr) + ')'\n\n def get_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError()\n return 'DT' + self.expr.get_id(version) + \"E\"\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode.append(nodes.Text('decltype('))\n self.expr.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTTrailingTypeSpecName(ASTTrailingTypeSpec):\n def __init__(self, prefix: str, nestedName: ASTNestedName) -> None:\n self.prefix = prefix\n self.nestedName = nestedName\n\n @property\n def name(self) -> ASTNestedName:\n return self.nestedName\n\n def get_id(self, version: int) -> str:\n return self.nestedName.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.prefix:\n res.append(self.prefix)\n res.append(' ')\n res.append(transform(self.nestedName))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n if self.prefix:\n signode += addnodes.desc_annotation(self.prefix, self.prefix)\n signode += nodes.Text(' ')\n self.nestedName.describe_signature(signode, mode, env, symbol=symbol)\n\n\nclass ASTFunctionParameter(ASTBase):\n def __init__(self, arg: Union[\"ASTTypeWithInit\",\n \"ASTTemplateParamConstrainedTypeWithInit\"],\n ellipsis: bool = False) -> None:\n self.arg = arg\n self.ellipsis = ellipsis\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n # this is not part of the normal name mangling in C++\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=None)\n # else, do the usual\n if self.ellipsis:\n return 'z'\n else:\n return self.arg.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.ellipsis:\n return '...'\n else:\n return transform(self.arg)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if self.ellipsis:\n signode += nodes.Text('...')\n else:\n self.arg.describe_signature(signode, mode, env, symbol=symbol)\n\n\nclass ASTParametersQualifiers(ASTBase):\n def __init__(self, args: List[ASTFunctionParameter],\n volatile: bool, const: bool, refQual: str,\n exceptionSpec: str, override: bool, final: bool, initializer: str) -> None:\n self.args = args\n self.volatile = volatile\n self.const = const\n self.refQual = refQual\n self.exceptionSpec = exceptionSpec\n self.override = override\n self.final = final\n self.initializer = initializer\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.args\n\n def get_modifiers_id(self, version: int) -> str:\n res = []\n if self.volatile:\n res.append('V')\n if self.const:\n if version == 1:\n res.append('C')\n else:\n res.append('K')\n if self.refQual == '&&':\n res.append('O')\n elif self.refQual == '&':\n res.append('R')\n return ''.join(res)\n\n def get_param_id(self, version: int) -> str:\n if version == 1:\n if len(self.args) == 0:\n return ''\n else:\n return '__' + '.'.join(a.get_id(version) for a in self.args)\n if len(self.args) == 0:\n return 'v'\n else:\n return ''.join(a.get_id(version) for a in self.args)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append('(')\n first = True\n for a in self.args:\n if not first:\n res.append(', ')\n first = False\n res.append(str(a))\n res.append(')')\n if self.volatile:\n res.append(' volatile')\n if self.const:\n res.append(' const')\n if self.refQual:\n res.append(' ')\n res.append(self.refQual)\n if self.exceptionSpec:\n res.append(' ')\n res.append(str(self.exceptionSpec))\n if self.final:\n res.append(' final')\n if self.override:\n res.append(' override')\n if self.initializer:\n res.append(' = ')\n res.append(self.initializer)\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n paramlist = addnodes.desc_parameterlist()\n for arg in self.args:\n param = addnodes.desc_parameter('', '', noemph=True)\n if mode == 'lastIsName': # i.e., outer-function params\n arg.describe_signature(param, 'param', env, symbol=symbol)\n else:\n arg.describe_signature(param, 'markType', env, symbol=symbol)\n paramlist += param\n signode += paramlist\n\n def _add_anno(signode: TextElement, text: str) -> None:\n signode += nodes.Text(' ')\n signode += addnodes.desc_annotation(text, text)\n\n def _add_text(signode: TextElement, text: str) -> None:\n signode += nodes.Text(' ' + text)\n\n if self.volatile:\n _add_anno(signode, 'volatile')\n if self.const:\n _add_anno(signode, 'const')\n if self.refQual:\n _add_text(signode, self.refQual)\n if self.exceptionSpec:\n _add_anno(signode, str(self.exceptionSpec))\n if self.final:\n _add_anno(signode, 'final')\n if self.override:\n _add_anno(signode, 'override')\n if self.initializer:\n _add_text(signode, '= ' + str(self.initializer))\n\n\nclass ASTDeclSpecsSimple(ASTBase):\n def __init__(self, storage: str, threadLocal: bool, inline: bool, virtual: bool,\n explicit: bool, constexpr: bool, volatile: bool, const: bool,\n friend: bool, attrs: List[ASTAttribute]) -> None:\n self.storage = storage\n self.threadLocal = threadLocal\n self.inline = inline\n self.virtual = virtual\n self.explicit = explicit\n self.constexpr = constexpr\n self.volatile = volatile\n self.const = const\n self.friend = friend\n self.attrs = attrs\n\n def mergeWith(self, other: \"ASTDeclSpecsSimple\") -> \"ASTDeclSpecsSimple\":\n if not other:\n return self\n return ASTDeclSpecsSimple(self.storage or other.storage,\n self.threadLocal or other.threadLocal,\n self.inline or other.inline,\n self.virtual or other.virtual,\n self.explicit or other.explicit,\n self.constexpr or other.constexpr,\n self.volatile or other.volatile,\n self.const or other.const,\n self.friend or other.friend,\n self.attrs + other.attrs)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = [] # type: List[str]\n res.extend(transform(attr) for attr in self.attrs)\n if self.storage:\n res.append(self.storage)\n if self.threadLocal:\n res.append('thread_local')\n if self.inline:\n res.append('inline')\n if self.friend:\n res.append('friend')\n if self.virtual:\n res.append('virtual')\n if self.explicit:\n res.append('explicit')\n if self.constexpr:\n res.append('constexpr')\n if self.volatile:\n res.append('volatile')\n if self.const:\n res.append('const')\n return ' '.join(res)\n\n def describe_signature(self, signode: TextElement) -> None:\n addSpace = False\n for attr in self.attrs:\n if addSpace:\n signode += nodes.Text(' ')\n addSpace = True\n attr.describe_signature(signode)\n\n def _add(signode: TextElement, text: str) -> bool:\n if addSpace:\n signode += nodes.Text(' ')\n signode += addnodes.desc_annotation(text, text)\n return True\n\n if self.storage:\n addSpace = _add(signode, self.storage)\n if self.threadLocal:\n addSpace = _add(signode, 'thread_local')\n if self.inline:\n addSpace = _add(signode, 'inline')\n if self.friend:\n addSpace = _add(signode, 'friend')\n if self.virtual:\n addSpace = _add(signode, 'virtual')\n if self.explicit:\n addSpace = _add(signode, 'explicit')\n if self.constexpr:\n addSpace = _add(signode, 'constexpr')\n if self.volatile:\n addSpace = _add(signode, 'volatile')\n if self.const:\n addSpace = _add(signode, 'const')\n\n\nclass ASTDeclSpecs(ASTBase):\n def __init__(self, outer: str,\n leftSpecs: ASTDeclSpecsSimple, rightSpecs: ASTDeclSpecsSimple,\n trailing: ASTTrailingTypeSpec) -> None:\n # leftSpecs and rightSpecs are used for output\n # allSpecs are used for id generation\n self.outer = outer\n self.leftSpecs = leftSpecs\n self.rightSpecs = rightSpecs\n self.allSpecs = self.leftSpecs.mergeWith(self.rightSpecs)\n self.trailingTypeSpec = trailing\n\n def get_id(self, version: int) -> str:\n if version == 1:\n res = []\n res.append(self.trailingTypeSpec.get_id(version))\n if self.allSpecs.volatile:\n res.append('V')\n if self.allSpecs.const:\n res.append('C')\n return ''.join(res)\n res = []\n if self.allSpecs.volatile:\n res.append('V')\n if self.allSpecs.const:\n res.append('K')\n if self.trailingTypeSpec is not None:\n res.append(self.trailingTypeSpec.get_id(version))\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = [] # type: List[str]\n l = transform(self.leftSpecs)\n if len(l) > 0:\n res.append(l)\n if self.trailingTypeSpec:\n if len(res) > 0:\n res.append(\" \")\n res.append(transform(self.trailingTypeSpec))\n r = str(self.rightSpecs)\n if len(r) > 0:\n if len(res) > 0:\n res.append(\" \")\n res.append(r)\n return \"\".join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n numChildren = len(signode)\n self.leftSpecs.describe_signature(signode)\n addSpace = len(signode) != numChildren\n\n if self.trailingTypeSpec:\n if addSpace:\n signode += nodes.Text(' ')\n numChildren = len(signode)\n self.trailingTypeSpec.describe_signature(signode, mode, env,\n symbol=symbol)\n addSpace = len(signode) != numChildren\n\n if len(str(self.rightSpecs)) > 0:\n if addSpace:\n signode += nodes.Text(' ')\n self.rightSpecs.describe_signature(signode)\n\n\n# Declarator\n################################################################################\n\nclass ASTArray(ASTBase):\n def __init__(self, size: ASTExpression):\n self.size = size\n\n def _stringify(self, transform: StringifyTransform) -> str:\n if self.size:\n return '[' + transform(self.size) + ']'\n else:\n return '[]'\n\n def get_id(self, version: int) -> str:\n if version == 1:\n return 'A'\n if version == 2:\n if self.size:\n return 'A' + str(self.size) + '_'\n else:\n return 'A_'\n if self.size:\n return 'A' + self.size.get_id(version) + '_'\n else:\n return 'A_'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode.append(nodes.Text(\"[\"))\n if self.size:\n self.size.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(\"]\"))\n\n\nclass ASTDeclarator(ASTBase):\n @property\n def name(self) -> ASTNestedName:\n raise NotImplementedError(repr(self))\n\n @property\n def isPack(self) -> bool:\n raise NotImplementedError(repr(self))\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n raise NotImplementedError(repr(self))\n\n def require_space_after_declSpecs(self) -> bool:\n raise NotImplementedError(repr(self))\n\n def get_modifiers_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def get_param_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def get_ptr_suffix_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n raise NotImplementedError(repr(self))\n\n def is_function_type(self) -> bool:\n raise NotImplementedError(repr(self))\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n raise NotImplementedError(repr(self))\n\n\nclass ASTDeclaratorNameParamQual(ASTDeclarator):\n def __init__(self, declId: ASTNestedName,\n arrayOps: List[ASTArray],\n paramQual: ASTParametersQualifiers) -> None:\n self.declId = declId\n self.arrayOps = arrayOps\n self.paramQual = paramQual\n\n @property\n def name(self) -> ASTNestedName:\n return self.declId\n\n @property\n def isPack(self) -> bool:\n return False\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.paramQual.function_params\n\n # only the modifiers for a function, e.g.,\n def get_modifiers_id(self, version: int) -> str:\n # cv-qualifiers\n if self.paramQual:\n return self.paramQual.get_modifiers_id(version)\n raise Exception(\"This should only be called on a function: %s\" % self)\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n if self.paramQual:\n return self.paramQual.get_param_id(version)\n else:\n return ''\n\n def get_ptr_suffix_id(self, version: int) -> str: # only the array specifiers\n return ''.join(a.get_id(version) for a in self.arrayOps)\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n assert version >= 2\n res = []\n # TOOD: can we actually have both array ops and paramQual?\n res.append(self.get_ptr_suffix_id(version))\n if self.paramQual:\n res.append(self.get_modifiers_id(version))\n res.append('F')\n res.append(returnTypeId)\n res.append(self.get_param_id(version))\n res.append('E')\n else:\n res.append(returnTypeId)\n return ''.join(res)\n\n # ------------------------------------------------------------------------\n\n def require_space_after_declSpecs(self) -> bool:\n return self.declId is not None\n\n def is_function_type(self) -> bool:\n return self.paramQual is not None\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.declId:\n res.append(transform(self.declId))\n for op in self.arrayOps:\n res.append(transform(op))\n if self.paramQual:\n res.append(transform(self.paramQual))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if self.declId:\n self.declId.describe_signature(signode, mode, env, symbol)\n for op in self.arrayOps:\n op.describe_signature(signode, mode, env, symbol)\n if self.paramQual:\n self.paramQual.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorNameBitField(ASTDeclarator):\n def __init__(self, declId: ASTNestedName, size: ASTExpression):\n self.declId = declId\n self.size = size\n\n @property\n def name(self) -> ASTNestedName:\n return self.declId\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n return ''\n\n def get_ptr_suffix_id(self, version: int) -> str: # only the array specifiers\n return ''\n\n # ------------------------------------------------------------------------\n\n def require_space_after_declSpecs(self) -> bool:\n return self.declId is not None\n\n def is_function_type(self) -> bool:\n return False\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.declId:\n res.append(transform(self.declId))\n res.append(\" : \")\n res.append(transform(self.size))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if self.declId:\n self.declId.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(' : ', ' : '))\n self.size.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorPtr(ASTDeclarator):\n def __init__(self, next: ASTDeclarator, volatile: bool, const: bool,\n attrs: List[ASTAttribute]) -> None:\n assert next\n self.next = next\n self.volatile = volatile\n self.const = const\n self.attrs = attrs\n\n @property\n def name(self) -> ASTNestedName:\n return self.next.name\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.next.function_params\n\n def require_space_after_declSpecs(self) -> bool:\n return self.next.require_space_after_declSpecs()\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ['*']\n for a in self.attrs:\n res.append(transform(a))\n if len(self.attrs) > 0 and (self.volatile or self.const):\n res.append(' ')\n if self.volatile:\n res.append('volatile')\n if self.const:\n if self.volatile:\n res.append(' ')\n res.append('const')\n if self.const or self.volatile or len(self.attrs) > 0:\n if self.next.require_space_after_declSpecs():\n res.append(' ')\n res.append(transform(self.next))\n return ''.join(res)\n\n def get_modifiers_id(self, version: int) -> str:\n return self.next.get_modifiers_id(version)\n\n def get_param_id(self, version: int) -> str:\n return self.next.get_param_id(version)\n\n def get_ptr_suffix_id(self, version: int) -> str:\n if version == 1:\n res = ['P']\n if self.volatile:\n res.append('V')\n if self.const:\n res.append('C')\n res.append(self.next.get_ptr_suffix_id(version))\n return ''.join(res)\n\n res = [self.next.get_ptr_suffix_id(version)]\n res.append('P')\n if self.volatile:\n res.append('V')\n if self.const:\n res.append('C')\n return ''.join(res)\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n # ReturnType *next, so we are part of the return type of 'next\n res = ['P']\n if self.volatile:\n res.append('V')\n if self.const:\n res.append('C')\n res.append(returnTypeId)\n return self.next.get_type_id(version, returnTypeId=''.join(res))\n\n def is_function_type(self) -> bool:\n return self.next.is_function_type()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode += nodes.Text(\"*\")\n for a in self.attrs:\n a.describe_signature(signode)\n if len(self.attrs) > 0 and (self.volatile or self.const):\n signode += nodes.Text(' ')\n\n def _add_anno(signode: TextElement, text: str) -> None:\n signode += addnodes.desc_annotation(text, text)\n if self.volatile:\n _add_anno(signode, 'volatile')\n if self.const:\n if self.volatile:\n signode += nodes.Text(' ')\n _add_anno(signode, 'const')\n if self.const or self.volatile or len(self.attrs) > 0:\n if self.next.require_space_after_declSpecs():\n signode += nodes.Text(' ')\n self.next.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorRef(ASTDeclarator):\n def __init__(self, next: ASTDeclarator, attrs: List[ASTAttribute]) -> None:\n assert next\n self.next = next\n self.attrs = attrs\n\n @property\n def name(self) -> ASTNestedName:\n return self.next.name\n\n @property\n def isPack(self) -> bool:\n return True\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.next.function_params\n\n def require_space_after_declSpecs(self) -> bool:\n return self.next.require_space_after_declSpecs()\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ['&']\n for a in self.attrs:\n res.append(transform(a))\n if len(self.attrs) > 0 and self.next.require_space_after_declSpecs():\n res.append(' ')\n res.append(transform(self.next))\n return ''.join(res)\n\n def get_modifiers_id(self, version: int) -> str:\n return self.next.get_modifiers_id(version)\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n return self.next.get_param_id(version)\n\n def get_ptr_suffix_id(self, version: int) -> str:\n if version == 1:\n return 'R' + self.next.get_ptr_suffix_id(version)\n else:\n return self.next.get_ptr_suffix_id(version) + 'R'\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n assert version >= 2\n # ReturnType &next, so we are part of the return type of 'next\n return self.next.get_type_id(version, returnTypeId='R' + returnTypeId)\n\n def is_function_type(self) -> bool:\n return self.next.is_function_type()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode += nodes.Text(\"&\")\n for a in self.attrs:\n a.describe_signature(signode)\n if len(self.attrs) > 0 and self.next.require_space_after_declSpecs():\n signode += nodes.Text(' ')\n self.next.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorParamPack(ASTDeclarator):\n def __init__(self, next: ASTDeclarator) -> None:\n assert next\n self.next = next\n\n @property\n def name(self) -> ASTNestedName:\n return self.next.name\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.next.function_params\n\n def require_space_after_declSpecs(self) -> bool:\n return False\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = transform(self.next)\n if self.next.name:\n res = ' ' + res\n return '...' + res\n\n def get_modifiers_id(self, version: int) -> str:\n return self.next.get_modifiers_id(version)\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n return self.next.get_param_id(version)\n\n def get_ptr_suffix_id(self, version: int) -> str:\n if version == 1:\n return 'Dp' + self.next.get_ptr_suffix_id(version)\n else:\n return self.next.get_ptr_suffix_id(version) + 'Dp'\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n assert version >= 2\n # ReturnType... next, so we are part of the return type of 'next\n return self.next.get_type_id(version, returnTypeId='Dp' + returnTypeId)\n\n def is_function_type(self) -> bool:\n return self.next.is_function_type()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode += nodes.Text(\"...\")\n if self.next.name:\n signode += nodes.Text(' ')\n self.next.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorMemPtr(ASTDeclarator):\n def __init__(self, className: ASTNestedName,\n const: bool, volatile: bool, next: ASTDeclarator) -> None:\n assert className\n assert next\n self.className = className\n self.const = const\n self.volatile = volatile\n self.next = next\n\n @property\n def name(self) -> ASTNestedName:\n return self.next.name\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.next.function_params\n\n def require_space_after_declSpecs(self) -> bool:\n return True\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.className))\n res.append('::*')\n if self.volatile:\n res.append('volatile')\n if self.const:\n if self.volatile:\n res.append(' ')\n res.append('const')\n if self.next.require_space_after_declSpecs():\n res.append(' ')\n res.append(transform(self.next))\n return ''.join(res)\n\n def get_modifiers_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError()\n else:\n return self.next.get_modifiers_id(version)\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n if version == 1:\n raise NoOldIdError()\n else:\n return self.next.get_param_id(version)\n\n def get_ptr_suffix_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError()\n else:\n raise NotImplementedError()\n return self.next.get_ptr_suffix_id(version) + 'Dp'\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n assert version >= 2\n # ReturnType name::* next, so we are part of the return type of next\n nextReturnTypeId = ''\n if self.volatile:\n nextReturnTypeId += 'V'\n if self.const:\n nextReturnTypeId += 'K'\n nextReturnTypeId += 'M'\n nextReturnTypeId += self.className.get_id(version)\n nextReturnTypeId += returnTypeId\n return self.next.get_type_id(version, nextReturnTypeId)\n\n def is_function_type(self) -> bool:\n return self.next.is_function_type()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.className.describe_signature(signode, mode, env, symbol)\n signode += nodes.Text('::*')\n\n def _add_anno(signode: TextElement, text: str) -> None:\n signode += addnodes.desc_annotation(text, text)\n if self.volatile:\n _add_anno(signode, 'volatile')\n if self.const:\n if self.volatile:\n signode += nodes.Text(' ')\n _add_anno(signode, 'const')\n if self.next.require_space_after_declSpecs():\n signode += nodes.Text(' ')\n self.next.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTDeclaratorParen(ASTDeclarator):\n def __init__(self, inner: ASTDeclarator, next: ASTDeclarator) -> None:\n assert inner\n assert next\n self.inner = inner\n self.next = next\n # TODO: we assume the name, params, and qualifiers are in inner\n\n @property\n def name(self) -> ASTNestedName:\n return self.inner.name\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.inner.function_params\n\n def require_space_after_declSpecs(self) -> bool:\n return True\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = ['(']\n res.append(transform(self.inner))\n res.append(')')\n res.append(transform(self.next))\n return ''.join(res)\n\n def get_modifiers_id(self, version: int) -> str:\n return self.inner.get_modifiers_id(version)\n\n def get_param_id(self, version: int) -> str: # only the parameters (if any)\n return self.inner.get_param_id(version)\n\n def get_ptr_suffix_id(self, version: int) -> str:\n if version == 1:\n raise NoOldIdError() # TODO: was this implemented before?\n return self.next.get_ptr_suffix_id(version) + \\\n self.inner.get_ptr_suffix_id(version)\n else:\n return self.inner.get_ptr_suffix_id(version) + \\\n self.next.get_ptr_suffix_id(version)\n\n def get_type_id(self, version: int, returnTypeId: str) -> str:\n assert version >= 2\n # ReturnType (inner)next, so 'inner' returns everything outside\n nextId = self.next.get_type_id(version, returnTypeId)\n return self.inner.get_type_id(version, returnTypeId=nextId)\n\n def is_function_type(self) -> bool:\n return self.inner.is_function_type()\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode += nodes.Text('(')\n self.inner.describe_signature(signode, mode, env, symbol)\n signode += nodes.Text(')')\n self.next.describe_signature(signode, \"noneIsName\", env, symbol)\n\n\n# Type and initializer stuff\n##############################################################################################\n\nclass ASTPackExpansionExpr(ASTExpression):\n def __init__(self, expr: Union[ASTExpression, ASTBracedInitList]):\n self.expr = expr\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.expr) + '...'\n\n def get_id(self, version: int) -> str:\n id = self.expr.get_id(version)\n return 'sp' + id\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.expr.describe_signature(signode, mode, env, symbol)\n signode += nodes.Text('...')\n\n\nclass ASTParenExprList(ASTBase):\n def __init__(self, exprs: List[Union[ASTExpression, ASTBracedInitList]]) -> None:\n self.exprs = exprs\n\n def get_id(self, version: int) -> str:\n return \"pi%sE\" % ''.join(e.get_id(version) for e in self.exprs)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n exprs = [transform(e) for e in self.exprs]\n return '(%s)' % ', '.join(exprs)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n signode.append(nodes.Text('('))\n first = True\n for e in self.exprs:\n if not first:\n signode.append(nodes.Text(', '))\n else:\n first = False\n e.describe_signature(signode, mode, env, symbol)\n signode.append(nodes.Text(')'))\n\n\nclass ASTInitializer(ASTBase):\n def __init__(self, value: Union[ASTExpression, ASTBracedInitList],\n hasAssign: bool = True) -> None:\n self.value = value\n self.hasAssign = hasAssign\n\n def _stringify(self, transform: StringifyTransform) -> str:\n val = transform(self.value)\n if self.hasAssign:\n return ' = ' + val\n else:\n return val\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if self.hasAssign:\n signode.append(nodes.Text(' = '))\n self.value.describe_signature(signode, 'markType', env, symbol)\n\n\nclass ASTType(ASTBase):\n def __init__(self, declSpecs: ASTDeclSpecs, decl: ASTDeclarator) -> None:\n assert declSpecs\n assert decl\n self.declSpecs = declSpecs\n self.decl = decl\n\n @property\n def name(self) -> ASTNestedName:\n return self.decl.name\n\n @property\n def isPack(self) -> bool:\n return self.decl.isPack\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n return self.decl.function_params\n\n def get_id(self, version: int, objectType: str = None,\n symbol: \"Symbol\" = None) -> str:\n if version == 1:\n res = []\n if objectType: # needs the name\n if objectType == 'function': # also modifiers\n res.append(symbol.get_full_nested_name().get_id(version))\n res.append(self.decl.get_param_id(version))\n res.append(self.decl.get_modifiers_id(version))\n if (self.declSpecs.leftSpecs.constexpr or\n (self.declSpecs.rightSpecs and\n self.declSpecs.rightSpecs.constexpr)):\n res.append('CE')\n elif objectType == 'type': # just the name\n res.append(symbol.get_full_nested_name().get_id(version))\n else:\n print(objectType)\n assert False\n else: # only type encoding\n if self.decl.is_function_type():\n raise NoOldIdError()\n res.append(self.declSpecs.get_id(version))\n res.append(self.decl.get_ptr_suffix_id(version))\n res.append(self.decl.get_param_id(version))\n return ''.join(res)\n # other versions\n res = []\n if objectType: # needs the name\n if objectType == 'function': # also modifiers\n modifiers = self.decl.get_modifiers_id(version)\n res.append(symbol.get_full_nested_name().get_id(version, modifiers))\n if version >= 4:\n # with templates we need to mangle the return type in as well\n templ = symbol.declaration.templatePrefix\n if templ is not None:\n typeId = self.decl.get_ptr_suffix_id(version)\n returnTypeId = self.declSpecs.get_id(version)\n res.append(typeId)\n res.append(returnTypeId)\n res.append(self.decl.get_param_id(version))\n elif objectType == 'type': # just the name\n res.append(symbol.get_full_nested_name().get_id(version))\n else:\n print(objectType)\n assert False\n else: # only type encoding\n # the 'returnType' of a non-function type is simply just the last\n # type, i.e., for 'int*' it is 'int'\n returnTypeId = self.declSpecs.get_id(version)\n typeId = self.decl.get_type_id(version, returnTypeId)\n res.append(typeId)\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n declSpecs = transform(self.declSpecs)\n res.append(declSpecs)\n if self.decl.require_space_after_declSpecs() and len(declSpecs) > 0:\n res.append(' ')\n res.append(transform(self.decl))\n return ''.join(res)\n\n def get_type_declaration_prefix(self) -> str:\n if self.declSpecs.trailingTypeSpec:\n return 'typedef'\n else:\n return 'type'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.declSpecs.describe_signature(signode, 'markType', env, symbol)\n if (self.decl.require_space_after_declSpecs() and\n len(str(self.declSpecs)) > 0):\n signode += nodes.Text(' ')\n # for parameters that don't really declare new names we get 'markType',\n # this should not be propagated, but be 'noneIsName'.\n if mode == 'markType':\n mode = 'noneIsName'\n self.decl.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTemplateParamConstrainedTypeWithInit(ASTBase):\n def __init__(self, type: ASTType, init: ASTType) -> None:\n assert type\n self.type = type\n self.init = init\n\n @property\n def name(self) -> ASTNestedName:\n return self.type.name\n\n @property\n def isPack(self) -> bool:\n return self.type.isPack\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n # this is not part of the normal name mangling in C++\n assert version >= 2\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=False)\n else:\n return self.type.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = transform(self.type)\n if self.init:\n res += \" = \"\n res += transform(self.init)\n return res\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.type.describe_signature(signode, mode, env, symbol)\n if self.init:\n signode += nodes.Text(\" = \")\n self.init.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTypeWithInit(ASTBase):\n def __init__(self, type: ASTType, init: ASTInitializer) -> None:\n self.type = type\n self.init = init\n\n @property\n def name(self) -> ASTNestedName:\n return self.type.name\n\n @property\n def isPack(self) -> bool:\n return self.type.isPack\n\n def get_id(self, version: int, objectType: str = None,\n symbol: \"Symbol\" = None) -> str:\n if objectType != 'member':\n return self.type.get_id(version, objectType)\n if version == 1:\n return (symbol.get_full_nested_name().get_id(version) + '__' +\n self.type.get_id(version))\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.type))\n if self.init:\n res.append(transform(self.init))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.type.describe_signature(signode, mode, env, symbol)\n if self.init:\n self.init.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTypeUsing(ASTBase):\n def __init__(self, name: ASTNestedName, type: ASTType) -> None:\n self.name = name\n self.type = type\n\n def get_id(self, version: int, objectType: str = None,\n symbol: \"Symbol\" = None) -> str:\n if version == 1:\n raise NoOldIdError()\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.name))\n if self.type:\n res.append(' = ')\n res.append(transform(self.type))\n return ''.join(res)\n\n def get_type_declaration_prefix(self) -> str:\n return 'using'\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.name.describe_signature(signode, mode, env, symbol=symbol)\n if self.type:\n signode += nodes.Text(' = ')\n self.type.describe_signature(signode, 'markType', env, symbol=symbol)\n\n\n# Other declarations\n##############################################################################################\n\nclass ASTConcept(ASTBase):\n def __init__(self, nestedName: ASTNestedName, initializer: ASTInitializer) -> None:\n self.nestedName = nestedName\n self.initializer = initializer\n\n @property\n def name(self) -> ASTNestedName:\n return self.nestedName\n\n def get_id(self, version: int, objectType: str = None,\n symbol: \"Symbol\" = None) -> str:\n if version == 1:\n raise NoOldIdError()\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = transform(self.nestedName)\n if self.initializer:\n res += transform(self.initializer)\n return res\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.nestedName.describe_signature(signode, mode, env, symbol)\n if self.initializer:\n self.initializer.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTBaseClass(ASTBase):\n def __init__(self, name: ASTNestedName, visibility: str,\n virtual: bool, pack: bool) -> None:\n self.name = name\n self.visibility = visibility\n self.virtual = virtual\n self.pack = pack\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n\n if self.visibility is not None:\n res.append(self.visibility)\n res.append(' ')\n if self.virtual:\n res.append('virtual ')\n res.append(transform(self.name))\n if self.pack:\n res.append('...')\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n if self.visibility is not None:\n signode += addnodes.desc_annotation(self.visibility,\n self.visibility)\n signode += nodes.Text(' ')\n if self.virtual:\n signode += addnodes.desc_annotation('virtual', 'virtual')\n signode += nodes.Text(' ')\n self.name.describe_signature(signode, 'markType', env, symbol=symbol)\n if self.pack:\n signode += nodes.Text('...')\n\n\nclass ASTClass(ASTBase):\n def __init__(self, name: ASTNestedName, final: bool, bases: List[ASTBaseClass]) -> None:\n self.name = name\n self.final = final\n self.bases = bases\n\n def get_id(self, version: int, objectType: str, symbol: \"Symbol\") -> str:\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.name))\n if self.final:\n res.append(' final')\n if len(self.bases) > 0:\n res.append(' : ')\n first = True\n for b in self.bases:\n if not first:\n res.append(', ')\n first = False\n res.append(transform(b))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.name.describe_signature(signode, mode, env, symbol=symbol)\n if self.final:\n signode += nodes.Text(' ')\n signode += addnodes.desc_annotation('final', 'final')\n if len(self.bases) > 0:\n signode += nodes.Text(' : ')\n for b in self.bases:\n b.describe_signature(signode, mode, env, symbol=symbol)\n signode += nodes.Text(', ')\n signode.pop()\n\n\nclass ASTUnion(ASTBase):\n def __init__(self, name: ASTNestedName) -> None:\n self.name = name\n\n def get_id(self, version: int, objectType: str, symbol: \"Symbol\") -> str:\n if version == 1:\n raise NoOldIdError()\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.name)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.name.describe_signature(signode, mode, env, symbol=symbol)\n\n\nclass ASTEnum(ASTBase):\n def __init__(self, name: ASTNestedName, scoped: str,\n underlyingType: ASTType) -> None:\n self.name = name\n self.scoped = scoped\n self.underlyingType = underlyingType\n\n def get_id(self, version: int, objectType: str, symbol: \"Symbol\") -> str:\n if version == 1:\n raise NoOldIdError()\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.scoped:\n res.append(self.scoped)\n res.append(' ')\n res.append(transform(self.name))\n if self.underlyingType:\n res.append(' : ')\n res.append(transform(self.underlyingType))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n # self.scoped has been done by the CPPEnumObject\n self.name.describe_signature(signode, mode, env, symbol=symbol)\n if self.underlyingType:\n signode += nodes.Text(' : ')\n self.underlyingType.describe_signature(signode, 'noneIsName',\n env, symbol=symbol)\n\n\nclass ASTEnumerator(ASTBase):\n def __init__(self, name: ASTNestedName, init: ASTInitializer) -> None:\n self.name = name\n self.init = init\n\n def get_id(self, version: int, objectType: str, symbol: \"Symbol\") -> str:\n if version == 1:\n raise NoOldIdError()\n return symbol.get_full_nested_name().get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.name))\n if self.init:\n res.append(transform(self.init))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n verify_description_mode(mode)\n self.name.describe_signature(signode, mode, env, symbol)\n if self.init:\n self.init.describe_signature(signode, 'markType', env, symbol)\n\n\n################################################################################\n# Templates\n################################################################################\n\n# Parameters\n################################################################################\n\nclass ASTTemplateParam(ASTBase):\n def get_identifier(self) -> ASTIdentifier:\n raise NotImplementedError(repr(self))\n\n def get_id(self, version: int) -> str:\n raise NotImplementedError(repr(self))\n\n def describe_signature(self, parentNode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n raise NotImplementedError(repr(self))\n\n\nclass ASTTemplateKeyParamPackIdDefault(ASTTemplateParam):\n def __init__(self, key: str, identifier: ASTIdentifier,\n parameterPack: bool, default: ASTType) -> None:\n assert key\n if parameterPack:\n assert default is None\n self.key = key\n self.identifier = identifier\n self.parameterPack = parameterPack\n self.default = default\n\n def get_identifier(self) -> ASTIdentifier:\n return self.identifier\n\n def get_id(self, version: int) -> str:\n assert version >= 2\n # this is not part of the normal name mangling in C++\n res = []\n if self.parameterPack:\n res.append('Dp')\n else:\n res.append('0') # we need to put something\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = [self.key]\n if self.parameterPack:\n if self.identifier:\n res.append(' ')\n res.append('...')\n if self.identifier:\n if not self.parameterPack:\n res.append(' ')\n res.append(transform(self.identifier))\n if self.default:\n res.append(' = ')\n res.append(transform(self.default))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode += nodes.Text(self.key)\n if self.parameterPack:\n if self.identifier:\n signode += nodes.Text(' ')\n signode += nodes.Text('...')\n if self.identifier:\n if not self.parameterPack:\n signode += nodes.Text(' ')\n self.identifier.describe_signature(signode, mode, env, '', '', symbol)\n if self.default:\n signode += nodes.Text(' = ')\n self.default.describe_signature(signode, 'markType', env, symbol)\n\n\nclass ASTTemplateParamType(ASTTemplateParam):\n def __init__(self, data: ASTTemplateKeyParamPackIdDefault) -> None:\n assert data\n self.data = data\n\n @property\n def name(self) -> ASTNestedName:\n id = self.get_identifier()\n return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False)\n\n @property\n def isPack(self) -> bool:\n return self.data.parameterPack\n\n def get_identifier(self) -> ASTIdentifier:\n return self.data.get_identifier()\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n # this is not part of the normal name mangling in C++\n assert version >= 2\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=False)\n else:\n return self.data.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.data)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.data.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTemplateParamTemplateType(ASTTemplateParam):\n def __init__(self, nestedParams: \"ASTTemplateParams\",\n data: ASTTemplateKeyParamPackIdDefault) -> None:\n assert nestedParams\n assert data\n self.nestedParams = nestedParams\n self.data = data\n\n @property\n def name(self) -> ASTNestedName:\n id = self.get_identifier()\n return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False)\n\n @property\n def isPack(self) -> bool:\n return self.data.parameterPack\n\n def get_identifier(self) -> ASTIdentifier:\n return self.data.get_identifier()\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n assert version >= 2\n # this is not part of the normal name mangling in C++\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=None)\n else:\n return self.nestedParams.get_id(version) + self.data.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.nestedParams) + transform(self.data)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.nestedParams.describe_signature(signode, 'noneIsName', env, symbol)\n signode += nodes.Text(' ')\n self.data.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTemplateParamNonType(ASTTemplateParam):\n def __init__(self,\n param: Union[ASTTypeWithInit,\n ASTTemplateParamConstrainedTypeWithInit]) -> None:\n assert param\n self.param = param\n\n @property\n def name(self) -> ASTNestedName:\n id = self.get_identifier()\n return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False)\n\n @property\n def isPack(self) -> bool:\n return self.param.isPack\n\n def get_identifier(self) -> ASTIdentifier:\n name = self.param.name\n if name:\n assert len(name.names) == 1\n assert name.names[0].identOrOp\n assert not name.names[0].templateArgs\n res = name.names[0].identOrOp\n assert isinstance(res, ASTIdentifier)\n return res\n else:\n return None\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n assert version >= 2\n # this is not part of the normal name mangling in C++\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=None)\n else:\n return '_' + self.param.get_id(version)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n return transform(self.param)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n self.param.describe_signature(signode, mode, env, symbol)\n\n\nclass ASTTemplateParams(ASTBase):\n def __init__(self, params: List[ASTTemplateParam]) -> None:\n assert params is not None\n self.params = params\n\n def get_id(self, version: int) -> str:\n assert version >= 2\n res = []\n res.append(\"I\")\n for param in self.params:\n res.append(param.get_id(version))\n res.append(\"E\")\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(\"template<\")\n res.append(\", \".join(transform(a) for a in self.params))\n res.append(\"> \")\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n signode += nodes.Text(\"template<\")\n first = True\n for param in self.params:\n if not first:\n signode += nodes.Text(\", \")\n first = False\n param.describe_signature(signode, mode, env, symbol)\n signode += nodes.Text(\">\")\n\n def describe_signature_as_introducer(\n self, parentNode: desc_signature, mode: str, env: \"BuildEnvironment\",\n symbol: \"Symbol\", lineSpec: bool) -> None:\n def makeLine(parentNode: desc_signature) -> addnodes.desc_signature_line:\n signode = addnodes.desc_signature_line()\n parentNode += signode\n signode.sphinx_line_type = 'templateParams'\n return signode\n lineNode = makeLine(parentNode)\n lineNode += nodes.Text(\"template<\")\n first = True\n for param in self.params:\n if not first:\n lineNode += nodes.Text(\", \")\n first = False\n if lineSpec:\n lineNode = makeLine(parentNode)\n param.describe_signature(lineNode, mode, env, symbol)\n if lineSpec and not first:\n lineNode = makeLine(parentNode)\n lineNode += nodes.Text(\">\")\n\n\n# Template introducers\n################################################################################\n\nclass ASTTemplateIntroductionParameter(ASTBase):\n def __init__(self, identifier: ASTIdentifier, parameterPack: bool) -> None:\n self.identifier = identifier\n self.parameterPack = parameterPack\n\n @property\n def name(self) -> ASTNestedName:\n id = self.get_identifier()\n return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False)\n\n @property\n def isPack(self) -> bool:\n return self.parameterPack\n\n def get_identifier(self) -> ASTIdentifier:\n return self.identifier\n\n def get_id(self, version: int, objectType: str = None, symbol: \"Symbol\" = None) -> str:\n assert version >= 2\n # this is not part of the normal name mangling in C++\n if symbol:\n # the anchor will be our parent\n return symbol.parent.declaration.get_id(version, prefixed=None)\n else:\n if self.parameterPack:\n return 'Dp'\n else:\n return '0' # we need to put something\n\n def get_id_as_arg(self, version: int) -> str:\n assert version >= 2\n # used for the implicit requires clause\n res = self.identifier.get_id(version)\n if self.parameterPack:\n return 'sp' + res\n else:\n return res\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.parameterPack:\n res.append('...')\n res.append(transform(self.identifier))\n return ''.join(res)\n\n def describe_signature(self, signode: TextElement, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\") -> None:\n if self.parameterPack:\n signode += nodes.Text('...')\n self.identifier.describe_signature(signode, mode, env, '', '', symbol)\n\n\nclass ASTTemplateIntroduction(ASTBase):\n def __init__(self, concept: ASTNestedName,\n params: List[ASTTemplateIntroductionParameter]) -> None:\n assert len(params) > 0\n self.concept = concept\n self.params = params\n\n def get_id(self, version: int) -> str:\n assert version >= 2\n # first do the same as a normal template parameter list\n res = []\n res.append(\"I\")\n for param in self.params:\n res.append(param.get_id(version))\n res.append(\"E\")\n # let's use X expr E, which is otherwise for constant template args\n res.append(\"X\")\n res.append(self.concept.get_id(version))\n res.append(\"I\")\n for param in self.params:\n res.append(param.get_id_as_arg(version))\n res.append(\"E\")\n res.append(\"E\")\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n res.append(transform(self.concept))\n res.append('{')\n res.append(', '.join(transform(param) for param in self.params))\n res.append('} ')\n return ''.join(res)\n\n def describe_signature_as_introducer(\n self, parentNode: desc_signature, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\", lineSpec: bool) -> None:\n # Note: 'lineSpec' has no effect on template introductions.\n signode = addnodes.desc_signature_line()\n parentNode += signode\n signode.sphinx_line_type = 'templateIntroduction'\n self.concept.describe_signature(signode, 'markType', env, symbol)\n signode += nodes.Text('{')\n first = True\n for param in self.params:\n if not first:\n signode += nodes.Text(', ')\n first = False\n param.describe_signature(signode, mode, env, symbol)\n signode += nodes.Text('}')\n\n\nclass ASTTemplateDeclarationPrefix(ASTBase):\n def __init__(self,\n templates: List[Union[ASTTemplateParams,\n ASTTemplateIntroduction]]) -> None:\n # templates is None means it's an explicit instantiation of a variable\n self.templates = templates\n\n def get_id(self, version: int) -> str:\n assert version >= 2\n # this is not part of a normal name mangling system\n res = []\n for t in self.templates:\n res.append(t.get_id(version))\n return ''.join(res)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n for t in self.templates:\n res.append(transform(t))\n return ''.join(res)\n\n def describe_signature(self, signode: desc_signature, mode: str,\n env: \"BuildEnvironment\", symbol: \"Symbol\", lineSpec: bool) -> None:\n verify_description_mode(mode)\n for t in self.templates:\n t.describe_signature_as_introducer(signode, 'lastIsName', env, symbol, lineSpec)\n\n\n################################################################################\n################################################################################\n\nclass ASTDeclaration(ASTBase):\n def __init__(self, objectType: str, directiveType: str, visibility: str,\n templatePrefix: ASTTemplateDeclarationPrefix, declaration: Any) -> None:\n self.objectType = objectType\n self.directiveType = directiveType\n self.visibility = visibility\n self.templatePrefix = templatePrefix\n self.declaration = declaration\n\n self.symbol = None # type: Symbol\n # set by CPPObject._add_enumerator_to_parent\n self.enumeratorScopedSymbol = None # type: Symbol\n\n def clone(self) -> \"ASTDeclaration\":\n if self.templatePrefix:\n templatePrefixClone = self.templatePrefix.clone()\n else:\n templatePrefixClone = None\n return ASTDeclaration(self.objectType, self.directiveType,\n self.visibility, templatePrefixClone,\n self.declaration.clone())\n\n @property\n def name(self) -> ASTNestedName:\n return self.declaration.name\n\n @property\n def function_params(self) -> List[ASTFunctionParameter]:\n if self.objectType != 'function':\n return None\n return self.declaration.function_params\n\n def get_id(self, version: int, prefixed: bool = True) -> str:\n if version == 1:\n if self.templatePrefix:\n raise NoOldIdError()\n if self.objectType == 'enumerator' and self.enumeratorScopedSymbol:\n return self.enumeratorScopedSymbol.declaration.get_id(version)\n return self.declaration.get_id(version, self.objectType, self.symbol)\n # version >= 2\n if self.objectType == 'enumerator' and self.enumeratorScopedSymbol:\n return self.enumeratorScopedSymbol.declaration.get_id(version, prefixed)\n if prefixed:\n res = [_id_prefix[version]]\n else:\n res = []\n if self.templatePrefix:\n res.append(self.templatePrefix.get_id(version))\n res.append(self.declaration.get_id(version, self.objectType, self.symbol))\n return ''.join(res)\n\n def get_newest_id(self) -> str:\n return self.get_id(_max_id, True)\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.visibility and self.visibility != \"public\":\n res.append(self.visibility)\n res.append(' ')\n if self.templatePrefix:\n res.append(transform(self.templatePrefix))\n res.append(transform(self.declaration))\n return ''.join(res)\n\n def describe_signature(self, signode: desc_signature, mode: str,\n env: \"BuildEnvironment\", options: Dict) -> None:\n verify_description_mode(mode)\n assert self.symbol\n # The caller of the domain added a desc_signature node.\n # Always enable multiline:\n signode['is_multiline'] = True\n # Put each line in a desc_signature_line node.\n mainDeclNode = addnodes.desc_signature_line()\n mainDeclNode.sphinx_line_type = 'declarator'\n mainDeclNode['add_permalink'] = not self.symbol.isRedeclaration\n\n if self.templatePrefix:\n self.templatePrefix.describe_signature(signode, mode, env,\n symbol=self.symbol,\n lineSpec=options.get('tparam-line-spec'))\n signode += mainDeclNode\n if self.visibility and self.visibility != \"public\":\n mainDeclNode += addnodes.desc_annotation(self.visibility + \" \",\n self.visibility + \" \")\n if self.objectType == 'type':\n prefix = self.declaration.get_type_declaration_prefix()\n prefix += ' '\n mainDeclNode += addnodes.desc_annotation(prefix, prefix)\n elif self.objectType == 'concept':\n mainDeclNode += addnodes.desc_annotation('concept ', 'concept ')\n elif self.objectType == 'member':\n pass\n elif self.objectType == 'function':\n pass\n elif self.objectType == 'class':\n assert self.directiveType in ('class', 'struct')\n prefix = self.directiveType + ' '\n mainDeclNode += addnodes.desc_annotation(prefix, prefix)\n elif self.objectType == 'union':\n mainDeclNode += addnodes.desc_annotation('union ', 'union ')\n elif self.objectType == 'enum':\n if self.directiveType == 'enum':\n prefix = 'enum '\n elif self.directiveType == 'enum-class':\n prefix = 'enum class '\n elif self.directiveType == 'enum-struct':\n prefix = 'enum struct '\n else:\n assert False # wrong directiveType used\n mainDeclNode += addnodes.desc_annotation(prefix, prefix)\n elif self.objectType == 'enumerator':\n mainDeclNode += addnodes.desc_annotation('enumerator ', 'enumerator ')\n else:\n assert False\n self.declaration.describe_signature(mainDeclNode, mode, env, self.symbol)\n\n\nclass ASTNamespace(ASTBase):\n def __init__(self, nestedName: ASTNestedName,\n templatePrefix: ASTTemplateDeclarationPrefix) -> None:\n self.nestedName = nestedName\n self.templatePrefix = templatePrefix\n\n def _stringify(self, transform: StringifyTransform) -> str:\n res = []\n if self.templatePrefix:\n res.append(transform(self.templatePrefix))\n res.append(transform(self.nestedName))\n return ''.join(res)\n\n\nclass SymbolLookupResult:\n def __init__(self, symbols: Iterator[\"Symbol\"], parentSymbol: \"Symbol\",\n identOrOp: Union[ASTIdentifier, ASTOperator], templateParams: Any,\n templateArgs: ASTTemplateArgs) -> None:\n self.symbols = symbols\n self.parentSymbol = parentSymbol\n self.identOrOp = identOrOp\n self.templateParams = templateParams\n self.templateArgs = templateArgs\n\n\nclass LookupKey:\n def __init__(self, data: List[Tuple[ASTNestedNameElement,\n Union[ASTTemplateParams,\n ASTTemplateIntroduction],\n str]]) -> None:\n self.data = data\n\n\nclass Symbol:\n debug_indent = 0\n debug_indent_string = \" \"\n debug_lookup = False\n debug_show_tree = False\n\n @staticmethod\n def debug_print(*args: Any) -> None:\n print(Symbol.debug_indent_string * Symbol.debug_indent, end=\"\")\n print(*args)\n\n def _assert_invariants(self) -> None:\n if not self.parent:\n # parent == None means global scope, so declaration means a parent\n assert not self.identOrOp\n assert not self.templateParams\n assert not self.templateArgs\n assert not self.declaration\n assert not self.docname\n else:\n if self.declaration:\n assert self.docname\n\n def __setattr__(self, key: str, value: Any) -> None:\n if key == \"children\":\n assert False\n else:\n return super().__setattr__(key, value)\n\n def __init__(self, parent: \"Symbol\", identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Union[ASTTemplateParams, ASTTemplateIntroduction],\n templateArgs: Any, declaration: ASTDeclaration, docname: str) -> None:\n self.parent = parent\n # declarations in a single directive are linked together\n self.siblingAbove = None # type: Symbol\n self.siblingBelow = None # type: Symbol\n self.identOrOp = identOrOp\n self.templateParams = templateParams # template<templateParams>\n self.templateArgs = templateArgs # identifier<templateArgs>\n self.declaration = declaration\n self.docname = docname\n self.isRedeclaration = False\n self._assert_invariants()\n\n # Remember to modify Symbol.remove if modifications to the parent change.\n self._children = [] # type: List[Symbol]\n self._anonChildren = [] # type: List[Symbol]\n # note: _children includes _anonChildren\n if self.parent:\n self.parent._children.append(self)\n if self.declaration:\n self.declaration.symbol = self\n\n # Do symbol addition after self._children has been initialised.\n self._add_template_and_function_params()\n\n def _fill_empty(self, declaration: ASTDeclaration, docname: str) -> None:\n self._assert_invariants()\n assert not self.declaration\n assert not self.docname\n assert declaration\n assert docname\n self.declaration = declaration\n self.declaration.symbol = self\n self.docname = docname\n self._assert_invariants()\n # and symbol addition should be done as well\n self._add_template_and_function_params()\n\n def _add_template_and_function_params(self) -> None:\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"_add_template_and_function_params:\")\n # Note: we may be called from _fill_empty, so the symbols we want\n # to add may actually already be present (as empty symbols).\n\n # add symbols for the template params\n if self.templateParams:\n for tp in self.templateParams.params:\n if not tp.get_identifier():\n continue\n # only add a declaration if we our self are from a declaration\n if self.declaration:\n decl = ASTDeclaration('templateParam', None, None, None, tp)\n else:\n decl = None\n nne = ASTNestedNameElement(tp.get_identifier(), None)\n nn = ASTNestedName([nne], [False], rooted=False)\n self._add_symbols(nn, [], decl, self.docname)\n # add symbols for function parameters, if any\n if self.declaration is not None and self.declaration.function_params is not None:\n for fp in self.declaration.function_params:\n if fp.arg is None:\n continue\n nn = fp.arg.name\n if nn is None:\n continue\n # (comparing to the template params: we have checked that we are a declaration)\n decl = ASTDeclaration('functionParam', None, None, None, fp)\n assert not nn.rooted\n assert len(nn.names) == 1\n self._add_symbols(nn, [], decl, self.docname)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n\n def remove(self) -> None:\n if self.parent is None:\n return\n assert self in self.parent._children\n self.parent._children.remove(self)\n self.parent = None\n\n def clear_doc(self, docname: str) -> None:\n newChildren = [] # type: List[Symbol]\n for sChild in self._children:\n sChild.clear_doc(docname)\n if sChild.declaration and sChild.docname == docname:\n sChild.declaration = None\n sChild.docname = None\n if sChild.siblingAbove is not None:\n sChild.siblingAbove.siblingBelow = sChild.siblingBelow\n if sChild.siblingBelow is not None:\n sChild.siblingBelow.siblingAbove = sChild.siblingAbove\n sChild.siblingAbove = None\n sChild.siblingBelow = None\n newChildren.append(sChild)\n self._children = newChildren\n\n def get_all_symbols(self) -> Iterator[Any]:\n yield self\n for sChild in self._children:\n for s in sChild.get_all_symbols():\n yield s\n\n @property\n def children_recurse_anon(self) -> Generator[\"Symbol\", None, None]:\n for c in self._children:\n yield c\n if not c.identOrOp.is_anon():\n continue\n\n yield from c.children_recurse_anon\n\n def get_lookup_key(self) -> \"LookupKey\":\n # The pickle files for the environment and for each document are distinct.\n # The environment has all the symbols, but the documents has xrefs that\n # must know their scope. A lookup key is essentially a specification of\n # how to find a specific symbol.\n symbols = []\n s = self\n while s.parent:\n symbols.append(s)\n s = s.parent\n symbols.reverse()\n key = []\n for s in symbols:\n nne = ASTNestedNameElement(s.identOrOp, s.templateArgs)\n if s.declaration is not None:\n key.append((nne, s.templateParams, s.declaration.get_newest_id()))\n else:\n key.append((nne, s.templateParams, None))\n return LookupKey(key)\n\n def get_full_nested_name(self) -> ASTNestedName:\n symbols = []\n s = self\n while s.parent:\n symbols.append(s)\n s = s.parent\n symbols.reverse()\n names = []\n templates = []\n for s in symbols:\n names.append(ASTNestedNameElement(s.identOrOp, s.templateArgs))\n templates.append(False)\n return ASTNestedName(names, templates, rooted=False)\n\n def _find_first_named_symbol(self, identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Any, templateArgs: ASTTemplateArgs,\n templateShorthand: bool, matchSelf: bool,\n recurseInAnon: bool, correctPrimaryTemplateArgs: bool\n ) -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_print(\"_find_first_named_symbol ->\")\n res = self._find_named_symbols(identOrOp, templateParams, templateArgs,\n templateShorthand, matchSelf, recurseInAnon,\n correctPrimaryTemplateArgs,\n searchInSiblings=False)\n try:\n return next(res)\n except StopIteration:\n return None\n\n def _find_named_symbols(self, identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Any, templateArgs: ASTTemplateArgs,\n templateShorthand: bool, matchSelf: bool,\n recurseInAnon: bool, correctPrimaryTemplateArgs: bool,\n searchInSiblings: bool) -> Iterator[\"Symbol\"]:\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"_find_named_symbols:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"self:\")\n print(self.to_string(Symbol.debug_indent + 1), end=\"\")\n Symbol.debug_print(\"identOrOp: \", identOrOp)\n Symbol.debug_print(\"templateParams: \", templateParams)\n Symbol.debug_print(\"templateArgs: \", templateArgs)\n Symbol.debug_print(\"templateShorthand: \", templateShorthand)\n Symbol.debug_print(\"matchSelf: \", matchSelf)\n Symbol.debug_print(\"recurseInAnon: \", recurseInAnon)\n Symbol.debug_print(\"correctPrimaryTemplateAargs:\", correctPrimaryTemplateArgs)\n Symbol.debug_print(\"searchInSiblings: \", searchInSiblings)\n\n def isSpecialization() -> bool:\n # the names of the template parameters must be given exactly as args\n # and params that are packs must in the args be the name expanded\n if len(templateParams.params) != len(templateArgs.args):\n return True\n # having no template params and no arguments is also a specialization\n if len(templateParams.params) == 0:\n return True\n for i in range(len(templateParams.params)):\n param = templateParams.params[i]\n arg = templateArgs.args[i]\n # TODO: doing this by string manipulation is probably not the most efficient\n paramName = str(param.name)\n argTxt = str(arg)\n isArgPackExpansion = argTxt.endswith('...')\n if param.isPack != isArgPackExpansion:\n return True\n argName = argTxt[:-3] if isArgPackExpansion else argTxt\n if paramName != argName:\n return True\n return False\n if correctPrimaryTemplateArgs:\n if templateParams is not None and templateArgs is not None:\n # If both are given, but it's not a specialization, then do lookup as if\n # there is no argument list.\n # For example: template<typename T> int A<T>::var;\n if not isSpecialization():\n templateArgs = None\n\n def matches(s: \"Symbol\") -> bool:\n if s.identOrOp != identOrOp:\n return False\n if (s.templateParams is None) != (templateParams is None):\n if templateParams is not None:\n # we query with params, they must match params\n return False\n if not templateShorthand:\n # we don't query with params, and we do care about them\n return False\n if templateParams:\n # TODO: do better comparison\n if str(s.templateParams) != str(templateParams):\n return False\n if (s.templateArgs is None) != (templateArgs is None):\n return False\n if s.templateArgs:\n # TODO: do better comparison\n if str(s.templateArgs) != str(templateArgs):\n return False\n return True\n\n def candidates() -> Generator[Symbol, None, None]:\n s = self\n if Symbol.debug_lookup:\n Symbol.debug_print(\"searching in self:\")\n print(s.to_string(Symbol.debug_indent + 1), end=\"\")\n while True:\n if matchSelf:\n yield s\n if recurseInAnon:\n yield from s.children_recurse_anon\n else:\n yield from s._children\n\n if s.siblingAbove is None:\n break\n s = s.siblingAbove\n if Symbol.debug_lookup:\n Symbol.debug_print(\"searching in sibling:\")\n print(s.to_string(Symbol.debug_indent + 1), end=\"\")\n\n for s in candidates():\n if Symbol.debug_lookup:\n Symbol.debug_print(\"candidate:\")\n print(s.to_string(Symbol.debug_indent + 1), end=\"\")\n if matches(s):\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"matches\")\n Symbol.debug_indent -= 3\n yield s\n if Symbol.debug_lookup:\n Symbol.debug_indent += 2\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n\n def _symbol_lookup(self, nestedName: ASTNestedName, templateDecls: List[Any],\n onMissingQualifiedSymbol: Callable[[\"Symbol\", Union[ASTIdentifier, ASTOperator], Any, ASTTemplateArgs], \"Symbol\"], # NOQA\n strictTemplateParamArgLists: bool, ancestorLookupType: str,\n templateShorthand: bool, matchSelf: bool,\n recurseInAnon: bool, correctPrimaryTemplateArgs: bool,\n searchInSiblings: bool) -> SymbolLookupResult:\n # ancestorLookupType: if not None, specifies the target type of the lookup\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"_symbol_lookup:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"self:\")\n print(self.to_string(Symbol.debug_indent + 1), end=\"\")\n Symbol.debug_print(\"nestedName: \", nestedName)\n Symbol.debug_print(\"templateDecls: \", templateDecls)\n Symbol.debug_print(\"strictTemplateParamArgLists:\", strictTemplateParamArgLists)\n Symbol.debug_print(\"ancestorLookupType:\", ancestorLookupType)\n Symbol.debug_print(\"templateShorthand: \", templateShorthand)\n Symbol.debug_print(\"matchSelf: \", matchSelf)\n Symbol.debug_print(\"recurseInAnon: \", recurseInAnon)\n Symbol.debug_print(\"correctPrimaryTemplateArgs: \", correctPrimaryTemplateArgs)\n Symbol.debug_print(\"searchInSiblings: \", searchInSiblings)\n\n if strictTemplateParamArgLists:\n # Each template argument list must have a template parameter list.\n # But to declare a template there must be an additional template parameter list.\n assert (nestedName.num_templates() == len(templateDecls) or\n nestedName.num_templates() + 1 == len(templateDecls))\n else:\n assert len(templateDecls) <= nestedName.num_templates() + 1\n\n names = nestedName.names\n\n # find the right starting point for lookup\n parentSymbol = self\n if nestedName.rooted:\n while parentSymbol.parent:\n parentSymbol = parentSymbol.parent\n if ancestorLookupType is not None:\n # walk up until we find the first identifier\n firstName = names[0]\n if not firstName.is_operator():\n while parentSymbol.parent:\n if parentSymbol.find_identifier(firstName.identOrOp,\n matchSelf=matchSelf,\n recurseInAnon=recurseInAnon,\n searchInSiblings=searchInSiblings):\n # if we are in the scope of a constructor but wants to\n # reference the class we need to walk one extra up\n if (len(names) == 1 and ancestorLookupType == 'class' and matchSelf and\n parentSymbol.parent and\n parentSymbol.parent.identOrOp == firstName.identOrOp):\n pass\n else:\n break\n parentSymbol = parentSymbol.parent\n\n if Symbol.debug_lookup:\n Symbol.debug_print(\"starting point:\")\n print(parentSymbol.to_string(Symbol.debug_indent + 1), end=\"\")\n\n # and now the actual lookup\n iTemplateDecl = 0\n for name in names[:-1]:\n identOrOp = name.identOrOp\n templateArgs = name.templateArgs\n if strictTemplateParamArgLists:\n # there must be a parameter list\n if templateArgs:\n assert iTemplateDecl < len(templateDecls)\n templateParams = templateDecls[iTemplateDecl]\n iTemplateDecl += 1\n else:\n templateParams = None\n else:\n # take the next template parameter list if there is one\n # otherwise it's ok\n if templateArgs and iTemplateDecl < len(templateDecls):\n templateParams = templateDecls[iTemplateDecl]\n iTemplateDecl += 1\n else:\n templateParams = None\n\n symbol = parentSymbol._find_first_named_symbol(\n identOrOp,\n templateParams, templateArgs,\n templateShorthand=templateShorthand,\n matchSelf=matchSelf,\n recurseInAnon=recurseInAnon,\n correctPrimaryTemplateArgs=correctPrimaryTemplateArgs)\n if symbol is None:\n symbol = onMissingQualifiedSymbol(parentSymbol, identOrOp,\n templateParams, templateArgs)\n if symbol is None:\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return None\n # We have now matched part of a nested name, and need to match more\n # so even if we should matchSelf before, we definitely shouldn't\n # even more. (see also issue #2666)\n matchSelf = False\n parentSymbol = symbol\n\n if Symbol.debug_lookup:\n Symbol.debug_print(\"handle last name from:\")\n print(parentSymbol.to_string(Symbol.debug_indent + 1), end=\"\")\n\n # handle the last name\n name = names[-1]\n identOrOp = name.identOrOp\n templateArgs = name.templateArgs\n if iTemplateDecl < len(templateDecls):\n assert iTemplateDecl + 1 == len(templateDecls)\n templateParams = templateDecls[iTemplateDecl]\n else:\n assert iTemplateDecl == len(templateDecls)\n templateParams = None\n\n symbols = parentSymbol._find_named_symbols(\n identOrOp, templateParams, templateArgs,\n templateShorthand=templateShorthand, matchSelf=matchSelf,\n recurseInAnon=recurseInAnon, correctPrimaryTemplateArgs=False,\n searchInSiblings=searchInSiblings)\n if Symbol.debug_lookup:\n symbols = list(symbols) # type: ignore\n Symbol.debug_indent -= 2\n return SymbolLookupResult(symbols, parentSymbol,\n identOrOp, templateParams, templateArgs)\n\n def _add_symbols(self, nestedName: ASTNestedName, templateDecls: List[Any],\n declaration: ASTDeclaration, docname: str) -> \"Symbol\":\n # Used for adding a whole path of symbols, where the last may or may not\n # be an actual declaration.\n\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"_add_symbols:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"tdecls:\", templateDecls)\n Symbol.debug_print(\"nn: \", nestedName)\n Symbol.debug_print(\"decl: \", declaration)\n Symbol.debug_print(\"doc: \", docname)\n\n def onMissingQualifiedSymbol(parentSymbol: \"Symbol\",\n identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Any, templateArgs: ASTTemplateArgs\n ) -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"_add_symbols, onMissingQualifiedSymbol:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"templateParams:\", templateParams)\n Symbol.debug_print(\"identOrOp: \", identOrOp)\n Symbol.debug_print(\"templateARgs: \", templateArgs)\n Symbol.debug_indent -= 2\n return Symbol(parent=parentSymbol, identOrOp=identOrOp,\n templateParams=templateParams,\n templateArgs=templateArgs, declaration=None,\n docname=None)\n\n lookupResult = self._symbol_lookup(nestedName, templateDecls,\n onMissingQualifiedSymbol,\n strictTemplateParamArgLists=True,\n ancestorLookupType=None,\n templateShorthand=False,\n matchSelf=False,\n recurseInAnon=False,\n correctPrimaryTemplateArgs=True,\n searchInSiblings=False)\n assert lookupResult is not None # we create symbols all the way, so that can't happen\n symbols = list(lookupResult.symbols)\n if len(symbols) == 0:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"_add_symbols, result, no symbol:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"templateParams:\", lookupResult.templateParams)\n Symbol.debug_print(\"identOrOp: \", lookupResult.identOrOp)\n Symbol.debug_print(\"templateArgs: \", lookupResult.templateArgs)\n Symbol.debug_print(\"declaration: \", declaration)\n Symbol.debug_print(\"docname: \", docname)\n Symbol.debug_indent -= 1\n symbol = Symbol(parent=lookupResult.parentSymbol,\n identOrOp=lookupResult.identOrOp,\n templateParams=lookupResult.templateParams,\n templateArgs=lookupResult.templateArgs,\n declaration=declaration,\n docname=docname)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return symbol\n\n if Symbol.debug_lookup:\n Symbol.debug_print(\"_add_symbols, result, symbols:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"number symbols:\", len(symbols))\n Symbol.debug_indent -= 1\n\n if not declaration:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"no delcaration\")\n Symbol.debug_indent -= 2\n # good, just a scope creation\n # TODO: what if we have more than one symbol?\n return symbols[0]\n\n noDecl = []\n withDecl = []\n dupDecl = []\n for s in symbols:\n if s.declaration is None:\n noDecl.append(s)\n elif s.isRedeclaration:\n dupDecl.append(s)\n else:\n withDecl.append(s)\n if Symbol.debug_lookup:\n Symbol.debug_print(\"#noDecl: \", len(noDecl))\n Symbol.debug_print(\"#withDecl:\", len(withDecl))\n Symbol.debug_print(\"#dupDecl: \", len(dupDecl))\n # With partial builds we may start with a large symbol tree stripped of declarations.\n # Essentially any combination of noDecl, withDecl, and dupDecls seems possible.\n # TODO: make partial builds fully work. What should happen when the primary symbol gets\n # deleted, and other duplicates exist? The full document should probably be rebuild.\n\n # First check if one of those with a declaration matches.\n # If it's a function, we need to compare IDs,\n # otherwise there should be only one symbol with a declaration.\n def makeCandSymbol() -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_print(\"begin: creating candidate symbol\")\n symbol = Symbol(parent=lookupResult.parentSymbol,\n identOrOp=lookupResult.identOrOp,\n templateParams=lookupResult.templateParams,\n templateArgs=lookupResult.templateArgs,\n declaration=declaration,\n docname=docname)\n if Symbol.debug_lookup:\n Symbol.debug_print(\"end: creating candidate symbol\")\n return symbol\n if len(withDecl) == 0:\n candSymbol = None\n else:\n candSymbol = makeCandSymbol()\n\n def handleDuplicateDeclaration(symbol: \"Symbol\", candSymbol: \"Symbol\") -> None:\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"redeclaration\")\n Symbol.debug_indent -= 1\n Symbol.debug_indent -= 2\n # Redeclaration of the same symbol.\n # Let the new one be there, but raise an error to the client\n # so it can use the real symbol as subscope.\n # This will probably result in a duplicate id warning.\n candSymbol.isRedeclaration = True\n raise _DuplicateSymbolError(symbol, declaration)\n\n if declaration.objectType != \"function\":\n assert len(withDecl) <= 1\n handleDuplicateDeclaration(withDecl[0], candSymbol)\n # (not reachable)\n\n # a function, so compare IDs\n candId = declaration.get_newest_id()\n if Symbol.debug_lookup:\n Symbol.debug_print(\"candId:\", candId)\n for symbol in withDecl:\n oldId = symbol.declaration.get_newest_id()\n if Symbol.debug_lookup:\n Symbol.debug_print(\"oldId: \", oldId)\n if candId == oldId:\n handleDuplicateDeclaration(symbol, candSymbol)\n # (not reachable)\n # no candidate symbol found with matching ID\n # if there is an empty symbol, fill that one\n if len(noDecl) == 0:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"no match, no empty, candSybmol is not None?:\", candSymbol is not None) # NOQA\n Symbol.debug_indent -= 2\n if candSymbol is not None:\n return candSymbol\n else:\n return makeCandSymbol()\n else:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"no match, but fill an empty declaration, candSybmol is not None?:\", candSymbol is not None) # NOQA\n Symbol.debug_indent -= 2\n if candSymbol is not None:\n candSymbol.remove()\n # assert len(noDecl) == 1\n # TODO: enable assertion when we at some point find out how to do cleanup\n # for now, just take the first one, it should work fine ... right?\n symbol = noDecl[0]\n # If someone first opened the scope, and then later\n # declares it, e.g,\n # .. namespace:: Test\n # .. namespace:: nullptr\n # .. class:: Test\n symbol._fill_empty(declaration, docname)\n return symbol\n\n def merge_with(self, other: \"Symbol\", docnames: List[str],\n env: \"BuildEnvironment\") -> None:\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"merge_with:\")\n assert other is not None\n\n def unconditionalAdd(self, otherChild):\n # TODO: hmm, should we prune by docnames?\n self._children.append(otherChild)\n otherChild.parent = self\n otherChild._assert_invariants()\n\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n for otherChild in other._children:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"otherChild:\\n\", otherChild.to_string(Symbol.debug_indent))\n Symbol.debug_indent += 1\n if otherChild.isRedeclaration:\n unconditionalAdd(self, otherChild)\n if Symbol.debug_lookup:\n Symbol.debug_print(\"isRedeclaration\")\n Symbol.debug_indent -= 1\n continue\n candiateIter = self._find_named_symbols(\n identOrOp=otherChild.identOrOp,\n templateParams=otherChild.templateParams,\n templateArgs=otherChild.templateArgs,\n templateShorthand=False, matchSelf=False,\n recurseInAnon=False, correctPrimaryTemplateArgs=False,\n searchInSiblings=False)\n candidates = list(candiateIter)\n\n if Symbol.debug_lookup:\n Symbol.debug_print(\"raw candidate symbols:\", len(candidates))\n symbols = [s for s in candidates if not s.isRedeclaration]\n if Symbol.debug_lookup:\n Symbol.debug_print(\"non-duplicate candidate symbols:\", len(symbols))\n\n if len(symbols) == 0:\n unconditionalAdd(self, otherChild)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n continue\n\n ourChild = None\n if otherChild.declaration is None:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"no declaration in other child\")\n ourChild = symbols[0]\n else:\n queryId = otherChild.declaration.get_newest_id()\n if Symbol.debug_lookup:\n Symbol.debug_print(\"queryId: \", queryId)\n for symbol in symbols:\n if symbol.declaration is None:\n if Symbol.debug_lookup:\n Symbol.debug_print(\"empty candidate\")\n # if in the end we have non matching, but have an empty one,\n # then just continue with that\n ourChild = symbol\n continue\n candId = symbol.declaration.get_newest_id()\n if Symbol.debug_lookup:\n Symbol.debug_print(\"candidate:\", candId)\n if candId == queryId:\n ourChild = symbol\n break\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n if ourChild is None:\n unconditionalAdd(self, otherChild)\n continue\n if otherChild.declaration and otherChild.docname in docnames:\n if not ourChild.declaration:\n ourChild._fill_empty(otherChild.declaration, otherChild.docname)\n elif ourChild.docname != otherChild.docname:\n name = str(ourChild.declaration)\n msg = __(\"Duplicate declaration, also defined in '%s'.\\n\"\n \"Declaration is '%s'.\")\n msg = msg % (ourChild.docname, name)\n logger.warning(msg, location=otherChild.docname)\n else:\n # Both have declarations, and in the same docname.\n # This can apparently happen, it should be safe to\n # just ignore it, right?\n # Hmm, only on duplicate declarations, right?\n msg = \"Internal C++ domain error during symbol merging.\\n\"\n msg += \"ourChild:\\n\" + ourChild.to_string(1)\n msg += \"\\notherChild:\\n\" + otherChild.to_string(1)\n logger.warning(msg, location=otherChild.docname)\n ourChild.merge_with(otherChild, docnames, env)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n\n def add_name(self, nestedName: ASTNestedName,\n templatePrefix: ASTTemplateDeclarationPrefix = None) -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"add_name:\")\n if templatePrefix:\n templateDecls = templatePrefix.templates\n else:\n templateDecls = []\n res = self._add_symbols(nestedName, templateDecls,\n declaration=None, docname=None)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n return res\n\n def add_declaration(self, declaration: ASTDeclaration, docname: str) -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"add_declaration:\")\n assert declaration\n assert docname\n nestedName = declaration.name\n if declaration.templatePrefix:\n templateDecls = declaration.templatePrefix.templates\n else:\n templateDecls = []\n res = self._add_symbols(nestedName, templateDecls, declaration, docname)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n return res\n\n def find_identifier(self, identOrOp: Union[ASTIdentifier, ASTOperator],\n matchSelf: bool, recurseInAnon: bool, searchInSiblings: bool\n ) -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"find_identifier:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"identOrOp: \", identOrOp)\n Symbol.debug_print(\"matchSelf: \", matchSelf)\n Symbol.debug_print(\"recurseInAnon: \", recurseInAnon)\n Symbol.debug_print(\"searchInSiblings:\", searchInSiblings)\n print(self.to_string(Symbol.debug_indent + 1), end=\"\")\n Symbol.debug_indent -= 2\n current = self\n while current is not None:\n if Symbol.debug_lookup:\n Symbol.debug_indent += 2\n Symbol.debug_print(\"trying:\")\n print(current.to_string(Symbol.debug_indent + 1), end=\"\")\n Symbol.debug_indent -= 2\n if matchSelf and current.identOrOp == identOrOp:\n return current\n children = current.children_recurse_anon if recurseInAnon else current._children\n for s in children:\n if s.identOrOp == identOrOp:\n return s\n if not searchInSiblings:\n break\n current = current.siblingAbove\n return None\n\n def direct_lookup(self, key: \"LookupKey\") -> \"Symbol\":\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"direct_lookup:\")\n Symbol.debug_indent += 1\n s = self\n for name, templateParams, id_ in key.data:\n if id_ is not None:\n res = None\n for cand in s._children:\n if cand.declaration is None:\n continue\n if cand.declaration.get_newest_id() == id_:\n res = cand\n break\n s = res\n else:\n identOrOp = name.identOrOp\n templateArgs = name.templateArgs\n s = s._find_first_named_symbol(identOrOp,\n templateParams, templateArgs,\n templateShorthand=False,\n matchSelf=False,\n recurseInAnon=False,\n correctPrimaryTemplateArgs=False)\n if Symbol.debug_lookup:\n Symbol.debug_print(\"name: \", name)\n Symbol.debug_print(\"templateParams:\", templateParams)\n Symbol.debug_print(\"id: \", id_)\n if s is not None:\n print(s.to_string(Symbol.debug_indent + 1), end=\"\")\n else:\n Symbol.debug_print(\"not found\")\n if s is None:\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return None\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return s\n\n def find_name(self, nestedName: ASTNestedName, templateDecls: List[Any],\n typ: str, templateShorthand: bool, matchSelf: bool,\n recurseInAnon: bool, searchInSiblings: bool) -> Tuple[List[\"Symbol\"], str]:\n # templateShorthand: missing template parameter lists for templates is ok\n # If the first component is None,\n # then the second component _may_ be a string explaining why.\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"find_name:\")\n Symbol.debug_indent += 1\n Symbol.debug_print(\"self:\")\n print(self.to_string(Symbol.debug_indent + 1), end=\"\")\n Symbol.debug_print(\"nestedName: \", nestedName)\n Symbol.debug_print(\"templateDecls: \", templateDecls)\n Symbol.debug_print(\"typ: \", typ)\n Symbol.debug_print(\"templateShorthand:\", templateShorthand)\n Symbol.debug_print(\"matchSelf: \", matchSelf)\n Symbol.debug_print(\"recurseInAnon: \", recurseInAnon)\n Symbol.debug_print(\"searchInSiblings: \", searchInSiblings)\n\n class QualifiedSymbolIsTemplateParam(Exception):\n pass\n\n def onMissingQualifiedSymbol(parentSymbol: \"Symbol\",\n identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Any,\n templateArgs: ASTTemplateArgs) -> \"Symbol\":\n # TODO: Maybe search without template args?\n # Though, the correctPrimaryTemplateArgs does\n # that for primary templates.\n # Is there another case where it would be good?\n if parentSymbol.declaration is not None:\n if parentSymbol.declaration.objectType == 'templateParam':\n raise QualifiedSymbolIsTemplateParam()\n return None\n\n try:\n lookupResult = self._symbol_lookup(nestedName, templateDecls,\n onMissingQualifiedSymbol,\n strictTemplateParamArgLists=False,\n ancestorLookupType=typ,\n templateShorthand=templateShorthand,\n matchSelf=matchSelf,\n recurseInAnon=recurseInAnon,\n correctPrimaryTemplateArgs=False,\n searchInSiblings=searchInSiblings)\n except QualifiedSymbolIsTemplateParam:\n return None, \"templateParamInQualified\"\n\n if lookupResult is None:\n # if it was a part of the qualification that could not be found\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return None, None\n\n res = list(lookupResult.symbols)\n if len(res) != 0:\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n return res, None\n\n if lookupResult.parentSymbol.declaration is not None:\n if lookupResult.parentSymbol.declaration.objectType == 'templateParam':\n return None, \"templateParamInQualified\"\n\n # try without template params and args\n symbol = lookupResult.parentSymbol._find_first_named_symbol(\n lookupResult.identOrOp, None, None,\n templateShorthand=templateShorthand, matchSelf=matchSelf,\n recurseInAnon=recurseInAnon, correctPrimaryTemplateArgs=False)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 2\n if symbol is not None:\n return [symbol], None\n else:\n return None, None\n\n def find_declaration(self, declaration: ASTDeclaration, typ: str, templateShorthand: bool,\n matchSelf: bool, recurseInAnon: bool) -> \"Symbol\":\n # templateShorthand: missing template parameter lists for templates is ok\n if Symbol.debug_lookup:\n Symbol.debug_indent += 1\n Symbol.debug_print(\"find_declaration:\")\n nestedName = declaration.name\n if declaration.templatePrefix:\n templateDecls = declaration.templatePrefix.templates\n else:\n templateDecls = []\n\n def onMissingQualifiedSymbol(parentSymbol: \"Symbol\",\n identOrOp: Union[ASTIdentifier, ASTOperator],\n templateParams: Any,\n templateArgs: ASTTemplateArgs) -> \"Symbol\":\n return None\n\n lookupResult = self._symbol_lookup(nestedName, templateDecls,\n onMissingQualifiedSymbol,\n strictTemplateParamArgLists=False,\n ancestorLookupType=typ,\n templateShorthand=templateShorthand,\n matchSelf=matchSelf,\n recurseInAnon=recurseInAnon,\n correctPrimaryTemplateArgs=False,\n searchInSiblings=False)\n if Symbol.debug_lookup:\n Symbol.debug_indent -= 1\n if lookupResult is None:\n return None\n\n symbols = list(lookupResult.symbols)\n if len(symbols) == 0:\n return None\n\n querySymbol = Symbol(parent=lookupResult.parentSymbol,\n identOrOp=lookupResult.identOrOp,\n templateParams=lookupResult.templateParams,\n templateArgs=lookupResult.templateArgs,\n declaration=declaration,\n docname='fakeDocnameForQuery')\n queryId = declaration.get_newest_id()\n for symbol in symbols:\n if symbol.declaration is None:\n continue\n candId = symbol.declaration.get_newest_id()\n if candId == queryId:\n querySymbol.remove()\n return symbol\n querySymbol.remove()\n return None\n\n def to_string(self, indent: int) -> str:\n res = [Symbol.debug_indent_string * indent]\n if not self.parent:\n res.append('::')\n else:\n if self.templateParams:\n res.append(str(self.templateParams))\n res.append('\\n')\n res.append(Symbol.debug_indent_string * indent)\n if self.identOrOp:\n res.append(str(self.identOrOp))\n else:\n res.append(str(self.declaration))\n if self.templateArgs:\n res.append(str(self.templateArgs))\n if self.declaration:\n res.append(\": \")\n if self.isRedeclaration:\n res.append('!!duplicate!! ')\n res.append(str(self.declaration))\n if self.docname:\n res.append('\\t(')\n res.append(self.docname)\n res.append(')')\n res.append('\\n')\n return ''.join(res)\n\n def dump(self, indent: int) -> str:\n res = [self.to_string(indent)]\n for c in self._children:\n res.append(c.dump(indent + 1))\n return ''.join(res)\n\n\nclass DefinitionParser(BaseParser):\n # those without signedness and size modifiers\n # see https://en.cppreference.com/w/cpp/language/types\n _simple_fundemental_types = (\n 'void', 'bool', 'char', 'wchar_t', 'char16_t', 'char32_t', 'int',\n 'float', 'double', 'auto'\n )\n\n _prefix_keys = ('class', 'struct', 'enum', 'union', 'typename')\n\n @property\n def language(self) -> str:\n return 'C++'\n\n @property\n def id_attributes(self):\n return self.config.cpp_id_attributes\n\n @property\n def paren_attributes(self):\n return self.config.cpp_paren_attributes\n\n def _parse_string(self) -> str:\n if self.current_char != '\"':\n return None\n startPos = self.pos\n self.pos += 1\n escape = False\n while True:\n if self.eof:\n self.fail(\"Unexpected end during inside string.\")\n elif self.current_char == '\"' and not escape:\n self.pos += 1\n break\n elif self.current_char == '\\\\':\n escape = True\n else:\n escape = False\n self.pos += 1\n return self.definition[startPos:self.pos]\n\n def _parse_literal(self) -> ASTLiteral:\n # -> integer-literal\n # | character-literal\n # | floating-literal\n # | string-literal\n # | boolean-literal -> \"false\" | \"true\"\n # | pointer-literal -> \"nullptr\"\n # | user-defined-literal\n self.skip_ws()\n if self.skip_word('nullptr'):\n return ASTPointerLiteral()\n if self.skip_word('true'):\n return ASTBooleanLiteral(True)\n if self.skip_word('false'):\n return ASTBooleanLiteral(False)\n for regex in [float_literal_re, binary_literal_re, hex_literal_re,\n integer_literal_re, octal_literal_re]:\n pos = self.pos\n if self.match(regex):\n while self.current_char in 'uUlLfF':\n self.pos += 1\n return ASTNumberLiteral(self.definition[pos:self.pos])\n\n string = self._parse_string()\n if string is not None:\n return ASTStringLiteral(string)\n\n # character-literal\n if self.match(char_literal_re):\n prefix = self.last_match.group(1) # may be None when no prefix\n data = self.last_match.group(2)\n try:\n return ASTCharLiteral(prefix, data)\n except UnicodeDecodeError as e:\n self.fail(\"Can not handle character literal. Internal error was: %s\" % e)\n except UnsupportedMultiCharacterCharLiteral:\n self.fail(\"Can not handle character literal\"\n \" resulting in multiple decoded characters.\")\n\n # TODO: user-defined lit\n return None\n\n def _parse_fold_or_paren_expression(self) -> ASTExpression:\n # \"(\" expression \")\"\n # fold-expression\n # -> ( cast-expression fold-operator ... )\n # | ( ... fold-operator cast-expression )\n # | ( cast-expression fold-operator ... fold-operator cast-expression\n if self.current_char != '(':\n return None\n self.pos += 1\n self.skip_ws()\n if self.skip_string_and_ws(\"...\"):\n # ( ... fold-operator cast-expression )\n if not self.match(_fold_operator_re):\n self.fail(\"Expected fold operator after '...' in fold expression.\")\n op = self.matched_text\n rightExpr = self._parse_cast_expression()\n if not self.skip_string(')'):\n self.fail(\"Expected ')' in end of fold expression.\")\n return ASTFoldExpr(None, op, rightExpr)\n # try first parsing a unary right fold, or a binary fold\n pos = self.pos\n try:\n self.skip_ws()\n leftExpr = self._parse_cast_expression()\n self.skip_ws()\n if not self.match(_fold_operator_re):\n self.fail(\"Expected fold operator after left expression in fold expression.\")\n op = self.matched_text\n self.skip_ws()\n if not self.skip_string_and_ws('...'):\n self.fail(\"Expected '...' after fold operator in fold expression.\")\n except DefinitionError as eFold:\n self.pos = pos\n # fall back to a paren expression\n try:\n res = self._parse_expression()\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expected ')' in end of parenthesized expression.\")\n except DefinitionError as eExpr:\n raise self._make_multi_error([\n (eFold, \"If fold expression\"),\n (eExpr, \"If parenthesized expression\")\n ], \"Error in fold expression or parenthesized expression.\")\n return ASTParenExpr(res)\n # now it definitely is a fold expression\n if self.skip_string(')'):\n return ASTFoldExpr(leftExpr, op, None)\n if not self.match(_fold_operator_re):\n self.fail(\"Expected fold operator or ')' after '...' in fold expression.\")\n if op != self.matched_text:\n self.fail(\"Operators are different in binary fold: '%s' and '%s'.\"\n % (op, self.matched_text))\n rightExpr = self._parse_cast_expression()\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expected ')' to end binary fold expression.\")\n return ASTFoldExpr(leftExpr, op, rightExpr)\n\n def _parse_primary_expression(self) -> ASTExpression:\n # literal\n # \"this\"\n # lambda-expression\n # \"(\" expression \")\"\n # fold-expression\n # id-expression -> we parse this with _parse_nested_name\n self.skip_ws()\n res = self._parse_literal() # type: ASTExpression\n if res is not None:\n return res\n self.skip_ws()\n if self.skip_word(\"this\"):\n return ASTThisLiteral()\n # TODO: try lambda expression\n res = self._parse_fold_or_paren_expression()\n if res is not None:\n return res\n nn = self._parse_nested_name()\n if nn is not None:\n return ASTIdExpression(nn)\n return None\n\n def _parse_initializer_list(self, name: str, open: str, close: str\n ) -> Tuple[List[Union[ASTExpression,\n ASTBracedInitList]],\n bool]:\n # Parse open and close with the actual initializer-list inbetween\n # -> initializer-clause '...'[opt]\n # | initializer-list ',' initializer-clause '...'[opt]\n self.skip_ws()\n if not self.skip_string_and_ws(open):\n return None, None\n if self.skip_string(close):\n return [], False\n\n exprs = [] # type: List[Union[ASTExpression, ASTBracedInitList]]\n trailingComma = False\n while True:\n self.skip_ws()\n expr = self._parse_initializer_clause()\n self.skip_ws()\n if self.skip_string('...'):\n exprs.append(ASTPackExpansionExpr(expr))\n else:\n exprs.append(expr)\n self.skip_ws()\n if self.skip_string(close):\n break\n if not self.skip_string_and_ws(','):\n self.fail(\"Error in %s, expected ',' or '%s'.\" % (name, close))\n if self.current_char == close and close == '}':\n self.pos += 1\n trailingComma = True\n break\n return exprs, trailingComma\n\n def _parse_paren_expression_list(self) -> ASTParenExprList:\n # -> '(' expression-list ')'\n # though, we relax it to also allow empty parens\n # as it's needed in some cases\n #\n # expression-list\n # -> initializer-list\n exprs, trailingComma = self._parse_initializer_list(\"parenthesized expression-list\",\n '(', ')')\n if exprs is None:\n return None\n return ASTParenExprList(exprs)\n\n def _parse_initializer_clause(self) -> Union[ASTExpression, ASTBracedInitList]:\n bracedInitList = self._parse_braced_init_list()\n if bracedInitList is not None:\n return bracedInitList\n return self._parse_assignment_expression(inTemplate=False)\n\n def _parse_braced_init_list(self) -> ASTBracedInitList:\n # -> '{' initializer-list ','[opt] '}'\n # | '{' '}'\n exprs, trailingComma = self._parse_initializer_list(\"braced-init-list\", '{', '}')\n if exprs is None:\n return None\n return ASTBracedInitList(exprs, trailingComma)\n\n def _parse_expression_list_or_braced_init_list(\n self\n ) -> Union[ASTParenExprList, ASTBracedInitList]:\n paren = self._parse_paren_expression_list()\n if paren is not None:\n return paren\n return self._parse_braced_init_list()\n\n def _parse_postfix_expression(self) -> ASTPostfixExpr:\n # -> primary\n # | postfix \"[\" expression \"]\"\n # | postfix \"[\" braced-init-list [opt] \"]\"\n # | postfix \"(\" expression-list [opt] \")\"\n # | postfix \".\" \"template\" [opt] id-expression\n # | postfix \"->\" \"template\" [opt] id-expression\n # | postfix \".\" pseudo-destructor-name\n # | postfix \"->\" pseudo-destructor-name\n # | postfix \"++\"\n # | postfix \"--\"\n # | simple-type-specifier \"(\" expression-list [opt] \")\"\n # | simple-type-specifier braced-init-list\n # | typename-specifier \"(\" expression-list [opt] \")\"\n # | typename-specifier braced-init-list\n # | \"dynamic_cast\" \"<\" type-id \">\" \"(\" expression \")\"\n # | \"static_cast\" \"<\" type-id \">\" \"(\" expression \")\"\n # | \"reinterpret_cast\" \"<\" type-id \">\" \"(\" expression \")\"\n # | \"const_cast\" \"<\" type-id \">\" \"(\" expression \")\"\n # | \"typeid\" \"(\" expression \")\"\n # | \"typeid\" \"(\" type-id \")\"\n\n prefixType = None\n prefix = None # type: Any\n self.skip_ws()\n\n cast = None\n for c in _id_explicit_cast:\n if self.skip_word_and_ws(c):\n cast = c\n break\n if cast is not None:\n prefixType = \"cast\"\n if not self.skip_string(\"<\"):\n self.fail(\"Expected '<' afer '%s'.\" % cast)\n typ = self._parse_type(False)\n self.skip_ws()\n if not self.skip_string_and_ws(\">\"):\n self.fail(\"Expected '>' after type in '%s'.\" % cast)\n if not self.skip_string(\"(\"):\n self.fail(\"Expected '(' in '%s'.\" % cast)\n\n def parser() -> ASTExpression:\n return self._parse_expression()\n expr = self._parse_expression_fallback([')'], parser)\n self.skip_ws()\n if not self.skip_string(\")\"):\n self.fail(\"Expected ')' to end '%s'.\" % cast)\n prefix = ASTExplicitCast(cast, typ, expr)\n elif self.skip_word_and_ws(\"typeid\"):\n prefixType = \"typeid\"\n if not self.skip_string_and_ws('('):\n self.fail(\"Expected '(' after 'typeid'.\")\n pos = self.pos\n try:\n typ = self._parse_type(False)\n prefix = ASTTypeId(typ, isType=True)\n if not self.skip_string(')'):\n self.fail(\"Expected ')' to end 'typeid' of type.\")\n except DefinitionError as eType:\n self.pos = pos\n try:\n\n def parser() -> ASTExpression:\n return self._parse_expression()\n expr = self._parse_expression_fallback([')'], parser)\n prefix = ASTTypeId(expr, isType=False)\n if not self.skip_string(')'):\n self.fail(\"Expected ')' to end 'typeid' of expression.\")\n except DefinitionError as eExpr:\n self.pos = pos\n header = \"Error in 'typeid(...)'.\"\n header += \" Expected type or expression.\"\n errors = []\n errors.append((eType, \"If type\"))\n errors.append((eExpr, \"If expression\"))\n raise self._make_multi_error(errors, header)\n else: # a primary expression or a type\n pos = self.pos\n try:\n prefix = self._parse_primary_expression()\n prefixType = 'expr'\n except DefinitionError as eOuter:\n self.pos = pos\n try:\n # we are potentially casting, so save parens for us\n # TODO: hmm, would we need to try both with operatorCast and with None?\n prefix = self._parse_type(False, 'operatorCast')\n prefixType = 'typeOperatorCast'\n # | simple-type-specifier \"(\" expression-list [opt] \")\"\n # | simple-type-specifier braced-init-list\n # | typename-specifier \"(\" expression-list [opt] \")\"\n # | typename-specifier braced-init-list\n self.skip_ws()\n if self.current_char != '(' and self.current_char != '{':\n self.fail(\"Expecting '(' or '{' after type in cast expression.\")\n except DefinitionError as eInner:\n self.pos = pos\n header = \"Error in postfix expression,\"\n header += \" expected primary expression or type.\"\n errors = []\n errors.append((eOuter, \"If primary expression\"))\n errors.append((eInner, \"If type\"))\n raise self._make_multi_error(errors, header)\n\n # and now parse postfixes\n postFixes = [] # type: List[ASTPostfixOp]\n while True:\n self.skip_ws()\n if prefixType in ['expr', 'cast', 'typeid']:\n if self.skip_string_and_ws('['):\n expr = self._parse_expression()\n self.skip_ws()\n if not self.skip_string(']'):\n self.fail(\"Expected ']' in end of postfix expression.\")\n postFixes.append(ASTPostfixArray(expr))\n continue\n if self.skip_string('.'):\n if self.skip_string('*'):\n # don't steal the dot\n self.pos -= 2\n elif self.skip_string('..'):\n # don't steal the dot\n self.pos -= 3\n else:\n name = self._parse_nested_name()\n postFixes.append(ASTPostfixMember(name))\n continue\n if self.skip_string('->'):\n if self.skip_string('*'):\n # don't steal the arrow\n self.pos -= 3\n else:\n name = self._parse_nested_name()\n postFixes.append(ASTPostfixMemberOfPointer(name))\n continue\n if self.skip_string('++'):\n postFixes.append(ASTPostfixInc())\n continue\n if self.skip_string('--'):\n postFixes.append(ASTPostfixDec())\n continue\n lst = self._parse_expression_list_or_braced_init_list()\n if lst is not None:\n postFixes.append(ASTPostfixCallExpr(lst))\n continue\n break\n return ASTPostfixExpr(prefix, postFixes)\n\n def _parse_unary_expression(self) -> ASTExpression:\n # -> postfix\n # | \"++\" cast\n # | \"--\" cast\n # | unary-operator cast -> (* | & | + | - | ! | ~) cast\n # The rest:\n # | \"sizeof\" unary\n # | \"sizeof\" \"(\" type-id \")\"\n # | \"sizeof\" \"...\" \"(\" identifier \")\"\n # | \"alignof\" \"(\" type-id \")\"\n # | noexcept-expression -> noexcept \"(\" expression \")\"\n # | new-expression\n # | delete-expression\n self.skip_ws()\n for op in _expression_unary_ops:\n # TODO: hmm, should we be able to backtrack here?\n if op[0] in 'cn':\n res = self.skip_word(op)\n else:\n res = self.skip_string(op)\n if res:\n expr = self._parse_cast_expression()\n return ASTUnaryOpExpr(op, expr)\n if self.skip_word_and_ws('sizeof'):\n if self.skip_string_and_ws('...'):\n if not self.skip_string_and_ws('('):\n self.fail(\"Expecting '(' after 'sizeof...'.\")\n if not self.match(identifier_re):\n self.fail(\"Expecting identifier for 'sizeof...'.\")\n ident = ASTIdentifier(self.matched_text)\n self.skip_ws()\n if not self.skip_string(\")\"):\n self.fail(\"Expecting ')' to end 'sizeof...'.\")\n return ASTSizeofParamPack(ident)\n if self.skip_string_and_ws('('):\n typ = self._parse_type(named=False)\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expecting ')' to end 'sizeof'.\")\n return ASTSizeofType(typ)\n expr = self._parse_unary_expression()\n return ASTSizeofExpr(expr)\n if self.skip_word_and_ws('alignof'):\n if not self.skip_string_and_ws('('):\n self.fail(\"Expecting '(' after 'alignof'.\")\n typ = self._parse_type(named=False)\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expecting ')' to end 'alignof'.\")\n return ASTAlignofExpr(typ)\n if self.skip_word_and_ws('noexcept'):\n if not self.skip_string_and_ws('('):\n self.fail(\"Expecting '(' after 'noexcept'.\")\n expr = self._parse_expression()\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expecting ')' to end 'noexcept'.\")\n return ASTNoexceptExpr(expr)\n # new-expression\n pos = self.pos\n rooted = self.skip_string('::')\n self.skip_ws()\n if not self.skip_word_and_ws('new'):\n self.pos = pos\n else:\n # new-placement[opt] new-type-id new-initializer[opt]\n # new-placement[opt] ( type-id ) new-initializer[opt]\n isNewTypeId = True\n if self.skip_string_and_ws('('):\n # either this is a new-placement or it's the second production\n # without placement, and it's actually the ( type-id ) part\n self.fail(\"Sorry, neither new-placement nor parenthesised type-id \"\n \"in new-epression is supported yet.\")\n # set isNewTypeId = False if it's (type-id)\n if isNewTypeId:\n declSpecs = self._parse_decl_specs(outer=None)\n decl = self._parse_declarator(named=False, paramMode=\"new\")\n else:\n self.fail(\"Sorry, parenthesised type-id in new expression not yet supported.\")\n lst = self._parse_expression_list_or_braced_init_list()\n return ASTNewExpr(rooted, isNewTypeId, ASTType(declSpecs, decl), lst)\n # delete-expression\n pos = self.pos\n rooted = self.skip_string('::')\n self.skip_ws()\n if not self.skip_word_and_ws('delete'):\n self.pos = pos\n else:\n array = self.skip_string_and_ws('[')\n if array and not self.skip_string_and_ws(']'):\n self.fail(\"Expected ']' in array delete-expression.\")\n expr = self._parse_cast_expression()\n return ASTDeleteExpr(rooted, array, expr)\n return self._parse_postfix_expression()\n\n def _parse_cast_expression(self) -> ASTExpression:\n # -> unary | \"(\" type-id \")\" cast\n pos = self.pos\n self.skip_ws()\n if self.skip_string('('):\n try:\n typ = self._parse_type(False)\n if not self.skip_string(')'):\n self.fail(\"Expected ')' in cast expression.\")\n expr = self._parse_cast_expression()\n return ASTCastExpr(typ, expr)\n except DefinitionError as exCast:\n self.pos = pos\n try:\n return self._parse_unary_expression()\n except DefinitionError as exUnary:\n errs = []\n errs.append((exCast, \"If type cast expression\"))\n errs.append((exUnary, \"If unary expression\"))\n raise self._make_multi_error(errs, \"Error in cast expression.\")\n else:\n return self._parse_unary_expression()\n\n def _parse_logical_or_expression(self, inTemplate: bool) -> ASTExpression:\n # logical-or = logical-and ||\n # logical-and = inclusive-or &&\n # inclusive-or = exclusive-or |\n # exclusive-or = and ^\n # and = equality &\n # equality = relational ==, !=\n # relational = shift <, >, <=, >=\n # shift = additive <<, >>\n # additive = multiplicative +, -\n # multiplicative = pm *, /, %\n # pm = cast .*, ->*\n def _parse_bin_op_expr(self: DefinitionParser,\n opId: int, inTemplate: bool) -> ASTExpression:\n if opId + 1 == len(_expression_bin_ops):\n def parser(inTemplate: bool) -> ASTExpression:\n return self._parse_cast_expression()\n else:\n def parser(inTemplate: bool) -> ASTExpression:\n return _parse_bin_op_expr(self, opId + 1, inTemplate=inTemplate)\n exprs = []\n ops = []\n exprs.append(parser(inTemplate=inTemplate))\n while True:\n self.skip_ws()\n if inTemplate and self.current_char == '>':\n break\n pos = self.pos\n oneMore = False\n for op in _expression_bin_ops[opId]:\n if op[0] in 'abcnox':\n if not self.skip_word(op):\n continue\n else:\n if not self.skip_string(op):\n continue\n if op == '&' and self.current_char == '&':\n # don't split the && 'token'\n self.pos -= 1\n # and btw. && has lower precedence, so we are done\n break\n try:\n expr = parser(inTemplate=inTemplate)\n exprs.append(expr)\n ops.append(op)\n oneMore = True\n break\n except DefinitionError:\n self.pos = pos\n if not oneMore:\n break\n return ASTBinOpExpr(exprs, ops)\n return _parse_bin_op_expr(self, 0, inTemplate=inTemplate)\n\n def _parse_conditional_expression_tail(self, orExprHead: Any) -> None:\n # -> \"?\" expression \":\" assignment-expression\n return None\n\n def _parse_assignment_expression(self, inTemplate: bool) -> ASTExpression:\n # -> conditional-expression\n # | logical-or-expression assignment-operator initializer-clause\n # | throw-expression\n # TODO: parse throw-expression: \"throw\" assignment-expression [opt]\n # if not a throw expression, then:\n # -> conditional-expression ->\n # logical-or-expression\n # | logical-or-expression \"?\" expression \":\" assignment-expression\n # | logical-or-expression assignment-operator initializer-clause\n exprs = [] # type: List[Union[ASTExpression, ASTBracedInitList]]\n ops = []\n orExpr = self._parse_logical_or_expression(inTemplate=inTemplate)\n exprs.append(orExpr)\n # TODO: handle ternary with _parse_conditional_expression_tail\n while True:\n oneMore = False\n self.skip_ws()\n for op in _expression_assignment_ops:\n if op[0] in 'anox':\n if not self.skip_word(op):\n continue\n else:\n if not self.skip_string(op):\n continue\n expr = self._parse_initializer_clause()\n exprs.append(expr)\n ops.append(op)\n oneMore = True\n if not oneMore:\n break\n if len(ops) == 0:\n return orExpr\n else:\n return ASTAssignmentExpr(exprs, ops)\n\n def _parse_constant_expression(self, inTemplate: bool) -> ASTExpression:\n # -> conditional-expression\n orExpr = self._parse_logical_or_expression(inTemplate=inTemplate)\n # TODO: use _parse_conditional_expression_tail\n return orExpr\n\n def _parse_expression(self) -> ASTExpression:\n # -> assignment-expression\n # | expression \",\" assignment-expresion\n exprs = [self._parse_assignment_expression(inTemplate=False)]\n while True:\n self.skip_ws()\n if not self.skip_string(','):\n break\n exprs.append(self._parse_assignment_expression(inTemplate=False))\n if len(exprs) == 1:\n return exprs[0]\n else:\n return ASTCommaExpr(exprs)\n\n def _parse_expression_fallback(self, end: List[str],\n parser: Callable[[], ASTExpression],\n allow: bool = True) -> ASTExpression:\n # Stupidly \"parse\" an expression.\n # 'end' should be a list of characters which ends the expression.\n\n # first try to use the provided parser\n prevPos = self.pos\n try:\n return parser()\n except DefinitionError as e:\n # some places (e.g., template parameters) we really don't want to use fallback,\n # and for testing we may want to globally disable it\n if not allow or not self.allowFallbackExpressionParsing:\n raise\n self.warn(\"Parsing of expression failed. Using fallback parser.\"\n \" Error was:\\n%s\" % e)\n self.pos = prevPos\n # and then the fallback scanning\n assert end is not None\n self.skip_ws()\n startPos = self.pos\n if self.match(_string_re):\n value = self.matched_text\n else:\n # TODO: add handling of more bracket-like things, and quote handling\n brackets = {'(': ')', '{': '}', '[': ']', '<': '>'}\n symbols = [] # type: List[str]\n while not self.eof:\n if (len(symbols) == 0 and self.current_char in end):\n break\n if self.current_char in brackets.keys():\n symbols.append(brackets[self.current_char])\n elif len(symbols) > 0 and self.current_char == symbols[-1]:\n symbols.pop()\n self.pos += 1\n if len(end) > 0 and self.eof:\n self.fail(\"Could not find end of expression starting at %d.\"\n % startPos)\n value = self.definition[startPos:self.pos].strip()\n return ASTFallbackExpr(value.strip())\n\n # ==========================================================================\n\n def _parse_operator(self) -> ASTOperator:\n self.skip_ws()\n # adapted from the old code\n # yay, a regular operator definition\n if self.match(_operator_re):\n return ASTOperatorBuildIn(self.matched_text)\n\n # new/delete operator?\n for op in 'new', 'delete':\n if not self.skip_word(op):\n continue\n self.skip_ws()\n if self.skip_string('['):\n self.skip_ws()\n if not self.skip_string(']'):\n self.fail('Expected \"]\" after \"operator ' + op + '[\"')\n op += '[]'\n return ASTOperatorBuildIn(op)\n\n # user-defined literal?\n if self.skip_string('\"\"'):\n self.skip_ws()\n if not self.match(identifier_re):\n self.fail(\"Expected user-defined literal suffix.\")\n identifier = ASTIdentifier(self.matched_text)\n return ASTOperatorLiteral(identifier)\n\n # oh well, looks like a cast operator definition.\n # In that case, eat another type.\n type = self._parse_type(named=False, outer=\"operatorCast\")\n return ASTOperatorType(type)\n\n def _parse_template_argument_list(self) -> ASTTemplateArgs:\n # template-argument-list: (but we include the < and > here\n # template-argument ...[opt]\n # template-argument-list, template-argument ...[opt]\n # template-argument:\n # constant-expression\n # type-id\n # id-expression\n self.skip_ws()\n if not self.skip_string_and_ws('<'):\n return None\n if self.skip_string('>'):\n return ASTTemplateArgs([], False)\n prevErrors = []\n templateArgs = [] # type: List[Union[ASTType, ASTTemplateArgConstant]]\n packExpansion = False\n while 1:\n pos = self.pos\n parsedComma = False\n parsedEnd = False\n try:\n type = self._parse_type(named=False)\n self.skip_ws()\n if self.skip_string_and_ws('...'):\n packExpansion = True\n parsedEnd = True\n if not self.skip_string('>'):\n self.fail('Expected \">\" after \"...\" in template argument list.')\n elif self.skip_string('>'):\n parsedEnd = True\n elif self.skip_string(','):\n parsedComma = True\n else:\n self.fail('Expected \"...>\", \">\" or \",\" in template argument list.')\n templateArgs.append(type)\n except DefinitionError as e:\n prevErrors.append((e, \"If type argument\"))\n self.pos = pos\n try:\n value = self._parse_constant_expression(inTemplate=True)\n self.skip_ws()\n if self.skip_string_and_ws('...'):\n packExpansion = True\n parsedEnd = True\n if not self.skip_string('>'):\n self.fail('Expected \">\" after \"...\" in template argument list.')\n elif self.skip_string('>'):\n parsedEnd = True\n elif self.skip_string(','):\n parsedComma = True\n else:\n self.fail('Expected \"...>\", \">\" or \",\" in template argument list.')\n templateArgs.append(ASTTemplateArgConstant(value))\n except DefinitionError as e:\n self.pos = pos\n prevErrors.append((e, \"If non-type argument\"))\n header = \"Error in parsing template argument list.\"\n raise self._make_multi_error(prevErrors, header)\n if parsedEnd:\n assert not parsedComma\n break\n else:\n assert not packExpansion\n return ASTTemplateArgs(templateArgs, packExpansion)\n\n def _parse_nested_name(self, memberPointer: bool = False) -> ASTNestedName:\n names = [] # type: List[ASTNestedNameElement]\n templates = [] # type: List[bool]\n\n self.skip_ws()\n rooted = False\n if self.skip_string('::'):\n rooted = True\n while 1:\n self.skip_ws()\n if len(names) > 0:\n template = self.skip_word_and_ws('template')\n else:\n template = False\n templates.append(template)\n identOrOp = None # type: Union[ASTIdentifier, ASTOperator]\n if self.skip_word_and_ws('operator'):\n identOrOp = self._parse_operator()\n else:\n if not self.match(identifier_re):\n if memberPointer and len(names) > 0:\n templates.pop()\n break\n self.fail(\"Expected identifier in nested name.\")\n identifier = self.matched_text\n # make sure there isn't a keyword\n if identifier in _keywords:\n self.fail(\"Expected identifier in nested name, \"\n \"got keyword: %s\" % identifier)\n identOrOp = ASTIdentifier(identifier)\n # try greedily to get template arguments,\n # but otherwise a < might be because we are in an expression\n pos = self.pos\n try:\n templateArgs = self._parse_template_argument_list()\n except DefinitionError as ex:\n self.pos = pos\n templateArgs = None\n self.otherErrors.append(ex)\n names.append(ASTNestedNameElement(identOrOp, templateArgs))\n\n self.skip_ws()\n if not self.skip_string('::'):\n if memberPointer:\n self.fail(\"Expected '::' in pointer to member (function).\")\n break\n return ASTNestedName(names, templates, rooted)\n\n # ==========================================================================\n\n def _parse_trailing_type_spec(self) -> ASTTrailingTypeSpec:\n # fundemental types\n self.skip_ws()\n for t in self._simple_fundemental_types:\n if self.skip_word(t):\n return ASTTrailingTypeSpecFundamental(t)\n\n # TODO: this could/should be more strict\n elements = []\n if self.skip_word_and_ws('signed'):\n elements.append('signed')\n elif self.skip_word_and_ws('unsigned'):\n elements.append('unsigned')\n while 1:\n if self.skip_word_and_ws('short'):\n elements.append('short')\n elif self.skip_word_and_ws('long'):\n elements.append('long')\n else:\n break\n if self.skip_word_and_ws('char'):\n elements.append('char')\n elif self.skip_word_and_ws('int'):\n elements.append('int')\n elif self.skip_word_and_ws('double'):\n elements.append('double')\n if len(elements) > 0:\n return ASTTrailingTypeSpecFundamental(' '.join(elements))\n\n # decltype\n self.skip_ws()\n if self.skip_word_and_ws('decltype'):\n if not self.skip_string_and_ws('('):\n self.fail(\"Expected '(' after 'decltype'.\")\n if self.skip_word_and_ws('auto'):\n if not self.skip_string(')'):\n self.fail(\"Expected ')' after 'decltype(auto'.\")\n return ASTTrailingTypeSpecDecltypeAuto()\n expr = self._parse_expression()\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail(\"Expected ')' after 'decltype(<expr>'.\")\n return ASTTrailingTypeSpecDecltype(expr)\n\n # prefixed\n prefix = None\n self.skip_ws()\n for k in self._prefix_keys:\n if self.skip_word_and_ws(k):\n prefix = k\n break\n nestedName = self._parse_nested_name()\n return ASTTrailingTypeSpecName(prefix, nestedName)\n\n def _parse_parameters_and_qualifiers(self, paramMode: str) -> ASTParametersQualifiers:\n if paramMode == 'new':\n return None\n self.skip_ws()\n if not self.skip_string('('):\n if paramMode == 'function':\n self.fail('Expecting \"(\" in parameters-and-qualifiers.')\n else:\n return None\n args = []\n self.skip_ws()\n if not self.skip_string(')'):\n while 1:\n self.skip_ws()\n if self.skip_string('...'):\n args.append(ASTFunctionParameter(None, True))\n self.skip_ws()\n if not self.skip_string(')'):\n self.fail('Expected \")\" after \"...\" in '\n 'parameters-and-qualifiers.')\n break\n # note: it seems that function arguments can always be named,\n # even in function pointers and similar.\n arg = self._parse_type_with_init(outer=None, named='single')\n # TODO: parse default parameters # TODO: didn't we just do that?\n args.append(ASTFunctionParameter(arg))\n\n self.skip_ws()\n if self.skip_string(','):\n continue\n elif self.skip_string(')'):\n break\n else:\n self.fail(\n 'Expecting \",\" or \")\" in parameters-and-qualifiers, '\n 'got \"%s\".' % self.current_char)\n\n # TODO: why did we have this bail-out?\n # does it hurt to parse the extra stuff?\n # it's needed for pointer to member functions\n if paramMode != 'function' and False:\n return ASTParametersQualifiers(\n args, None, None, None, None, None, None, None)\n\n self.skip_ws()\n const = self.skip_word_and_ws('const')\n volatile = self.skip_word_and_ws('volatile')\n if not const: # the can be permuted\n const = self.skip_word_and_ws('const')\n\n refQual = None\n if self.skip_string('&&'):\n refQual = '&&'\n if not refQual and self.skip_string('&'):\n refQual = '&'\n\n exceptionSpec = None\n override = None\n final = None\n initializer = None\n self.skip_ws()\n if self.skip_string('noexcept'):\n exceptionSpec = 'noexcept'\n self.skip_ws()\n if self.skip_string('('):\n self.fail('Parameterised \"noexcept\" not yet implemented.')\n\n self.skip_ws()\n override = self.skip_word_and_ws('override')\n final = self.skip_word_and_ws('final')\n if not override:\n override = self.skip_word_and_ws(\n 'override') # they can be permuted\n\n self.skip_ws()\n if self.skip_string('='):\n self.skip_ws()\n valid = ('0', 'delete', 'default')\n for w in valid:\n if self.skip_word_and_ws(w):\n initializer = w\n break\n if not initializer:\n self.fail(\n 'Expected \"%s\" in initializer-specifier.'\n % '\" or \"'.join(valid))\n\n return ASTParametersQualifiers(\n args, volatile, const, refQual, exceptionSpec, override, final,\n initializer)\n\n def _parse_decl_specs_simple(self, outer: str, typed: bool) -> ASTDeclSpecsSimple:\n \"\"\"Just parse the simple ones.\"\"\"\n storage = None\n threadLocal = None\n inline = None\n virtual = None\n explicit = None\n constexpr = None\n volatile = None\n const = None\n friend = None\n attrs = []\n while 1: # accept any permutation of a subset of some decl-specs\n self.skip_ws()\n if not storage:\n if outer in ('member', 'function'):\n if self.skip_word('static'):\n storage = 'static'\n continue\n if self.skip_word('extern'):\n storage = 'extern'\n continue\n if outer == 'member':\n if self.skip_word('mutable'):\n storage = 'mutable'\n continue\n if self.skip_word('register'):\n storage = 'register'\n continue\n if not threadLocal and outer == 'member':\n threadLocal = self.skip_word('thread_local')\n if threadLocal:\n continue\n\n if outer == 'function':\n # function-specifiers\n if not inline:\n inline = self.skip_word('inline')\n if inline:\n continue\n if not friend:\n friend = self.skip_word('friend')\n if friend:\n continue\n if not virtual:\n virtual = self.skip_word('virtual')\n if virtual:\n continue\n if not explicit:\n explicit = self.skip_word('explicit')\n if explicit:\n continue\n\n if not constexpr and outer in ('member', 'function'):\n constexpr = self.skip_word(\"constexpr\")\n if constexpr:\n continue\n if not volatile and typed:\n volatile = self.skip_word('volatile')\n if volatile:\n continue\n if not const and typed:\n const = self.skip_word('const')\n if const:\n continue\n attr = self._parse_attribute()\n if attr:\n attrs.append(attr)\n continue\n break\n return ASTDeclSpecsSimple(storage, threadLocal, inline, virtual,\n explicit, constexpr, volatile, const,\n friend, attrs)\n\n def _parse_decl_specs(self, outer: str, typed: bool = True) -> ASTDeclSpecs:\n if outer:\n if outer not in ('type', 'member', 'function', 'templateParam'):\n raise Exception('Internal error, unknown outer \"%s\".' % outer)\n \"\"\"\n storage-class-specifier function-specifier \"constexpr\"\n \"volatile\" \"const\" trailing-type-specifier\n\n storage-class-specifier ->\n \"static\" (only for member_object and function_object)\n | \"register\"\n\n function-specifier -> \"inline\" | \"virtual\" | \"explicit\" (only for\n function_object)\n\n \"constexpr\" (only for member_object and function_object)\n \"\"\"\n leftSpecs = self._parse_decl_specs_simple(outer, typed)\n rightSpecs = None\n\n if typed:\n trailing = self._parse_trailing_type_spec()\n rightSpecs = self._parse_decl_specs_simple(outer, typed)\n else:\n trailing = None\n return ASTDeclSpecs(outer, leftSpecs, rightSpecs, trailing)\n\n def _parse_declarator_name_suffix(\n self, named: Union[bool, str], paramMode: str, typed: bool\n ) -> Union[ASTDeclaratorNameParamQual, ASTDeclaratorNameBitField]:\n # now we should parse the name, and then suffixes\n if named == 'maybe':\n pos = self.pos\n try:\n declId = self._parse_nested_name()\n except DefinitionError:\n self.pos = pos\n declId = None\n elif named == 'single':\n if self.match(identifier_re):\n identifier = ASTIdentifier(self.matched_text)\n nne = ASTNestedNameElement(identifier, None)\n declId = ASTNestedName([nne], [False], rooted=False)\n # if it's a member pointer, we may have '::', which should be an error\n self.skip_ws()\n if self.current_char == ':':\n self.fail(\"Unexpected ':' after identifier.\")\n else:\n declId = None\n elif named:\n declId = self._parse_nested_name()\n else:\n declId = None\n arrayOps = []\n while 1:\n self.skip_ws()\n if typed and self.skip_string('['):\n self.skip_ws()\n if self.skip_string(']'):\n arrayOps.append(ASTArray(None))\n continue\n\n def parser() -> ASTExpression:\n return self._parse_expression()\n value = self._parse_expression_fallback([']'], parser)\n if not self.skip_string(']'):\n self.fail(\"Expected ']' in end of array operator.\")\n arrayOps.append(ASTArray(value))\n continue\n else:\n break\n paramQual = self._parse_parameters_and_qualifiers(paramMode)\n if paramQual is None and len(arrayOps) == 0:\n # perhaps a bit-field\n if named and paramMode == 'type' and typed:\n self.skip_ws()\n if self.skip_string(':'):\n size = self._parse_constant_expression(inTemplate=False)\n return ASTDeclaratorNameBitField(declId=declId, size=size)\n return ASTDeclaratorNameParamQual(declId=declId, arrayOps=arrayOps,\n paramQual=paramQual)\n\n def _parse_declarator(self, named: Union[bool, str], paramMode: str,\n typed: bool = True\n ) -> ASTDeclarator:\n # 'typed' here means 'parse return type stuff'\n if paramMode not in ('type', 'function', 'operatorCast', 'new'):\n raise Exception(\n \"Internal error, unknown paramMode '%s'.\" % paramMode)\n prevErrors = []\n self.skip_ws()\n if typed and self.skip_string('*'):\n self.skip_ws()\n volatile = False\n const = False\n attrs = []\n while 1:\n if not volatile:\n volatile = self.skip_word_and_ws('volatile')\n if volatile:\n continue\n if not const:\n const = self.skip_word_and_ws('const')\n if const:\n continue\n attr = self._parse_attribute()\n if attr is not None:\n attrs.append(attr)\n continue\n break\n next = self._parse_declarator(named, paramMode, typed)\n return ASTDeclaratorPtr(next=next, volatile=volatile, const=const, attrs=attrs)\n # TODO: shouldn't we parse an R-value ref here first?\n if typed and self.skip_string(\"&\"):\n attrs = []\n while 1:\n attr = self._parse_attribute()\n if attr is None:\n break\n attrs.append(attr)\n next = self._parse_declarator(named, paramMode, typed)\n return ASTDeclaratorRef(next=next, attrs=attrs)\n if typed and self.skip_string(\"...\"):\n next = self._parse_declarator(named, paramMode, False)\n return ASTDeclaratorParamPack(next=next)\n if typed and self.current_char == '(': # note: peeking, not skipping\n if paramMode == \"operatorCast\":\n # TODO: we should be able to parse cast operators which return\n # function pointers. For now, just hax it and ignore.\n return ASTDeclaratorNameParamQual(declId=None, arrayOps=[],\n paramQual=None)\n # maybe this is the beginning of params and quals,try that first,\n # otherwise assume it's noptr->declarator > ( ptr-declarator )\n pos = self.pos\n try:\n # assume this is params and quals\n res = self._parse_declarator_name_suffix(named, paramMode,\n typed)\n return res\n except DefinitionError as exParamQual:\n prevErrors.append((exParamQual,\n \"If declarator-id with parameters-and-qualifiers\"))\n self.pos = pos\n try:\n assert self.current_char == '('\n self.skip_string('(')\n # TODO: hmm, if there is a name, it must be in inner, right?\n # TODO: hmm, if there must be parameters, they must be\n # inside, right?\n inner = self._parse_declarator(named, paramMode, typed)\n if not self.skip_string(')'):\n self.fail(\"Expected ')' in \\\"( ptr-declarator )\\\"\")\n next = self._parse_declarator(named=False,\n paramMode=\"type\",\n typed=typed)\n return ASTDeclaratorParen(inner=inner, next=next)\n except DefinitionError as exNoPtrParen:\n self.pos = pos\n prevErrors.append((exNoPtrParen, \"If parenthesis in noptr-declarator\"))\n header = \"Error in declarator\"\n raise self._make_multi_error(prevErrors, header)\n if typed: # pointer to member\n pos = self.pos\n try:\n name = self._parse_nested_name(memberPointer=True)\n self.skip_ws()\n if not self.skip_string('*'):\n self.fail(\"Expected '*' in pointer to member declarator.\")\n self.skip_ws()\n except DefinitionError as e:\n self.pos = pos\n prevErrors.append((e, \"If pointer to member declarator\"))\n else:\n volatile = False\n const = False\n while 1:\n if not volatile:\n volatile = self.skip_word_and_ws('volatile')\n if volatile:\n continue\n if not const:\n const = self.skip_word_and_ws('const')\n if const:\n continue\n break\n next = self._parse_declarator(named, paramMode, typed)\n return ASTDeclaratorMemPtr(name, const, volatile, next=next)\n pos = self.pos\n try:\n res = self._parse_declarator_name_suffix(named, paramMode, typed)\n # this is a heuristic for error messages, for when there is a < after a\n # nested name, but it was not a successful template argument list\n if self.current_char == '<':\n self.otherErrors.append(self._make_multi_error(prevErrors, \"\"))\n return res\n except DefinitionError as e:\n self.pos = pos\n prevErrors.append((e, \"If declarator-id\"))\n header = \"Error in declarator or parameters-and-qualifiers\"\n raise self._make_multi_error(prevErrors, header)\n\n def _parse_initializer(self, outer: str = None, allowFallback: bool = True\n ) -> ASTInitializer:\n # initializer # global vars\n # -> brace-or-equal-initializer\n # | '(' expression-list ')'\n #\n # brace-or-equal-initializer # member vars\n # -> '=' initializer-clause\n # | braced-init-list\n #\n # initializer-clause # function params, non-type template params (with '=' in front)\n # -> assignment-expression\n # | braced-init-list\n #\n # we don't distinguish between global and member vars, so disallow paren:\n #\n # -> braced-init-list # var only\n # | '=' assignment-expression\n # | '=' braced-init-list\n self.skip_ws()\n if outer == 'member':\n bracedInit = self._parse_braced_init_list()\n if bracedInit is not None:\n return ASTInitializer(bracedInit, hasAssign=False)\n\n if not self.skip_string('='):\n return None\n\n bracedInit = self._parse_braced_init_list()\n if bracedInit is not None:\n return ASTInitializer(bracedInit)\n\n if outer == 'member':\n fallbackEnd = [] # type: List[str]\n elif outer == 'templateParam':\n fallbackEnd = [',', '>']\n elif outer is None: # function parameter\n fallbackEnd = [',', ')']\n else:\n self.fail(\"Internal error, initializer for outer '%s' not \"\n \"implemented.\" % outer)\n\n inTemplate = outer == 'templateParam'\n\n def parser() -> ASTExpression:\n return self._parse_assignment_expression(inTemplate=inTemplate)\n value = self._parse_expression_fallback(fallbackEnd, parser, allow=allowFallback)\n return ASTInitializer(value)\n\n def _parse_type(self, named: Union[bool, str], outer: str = None) -> ASTType:\n \"\"\"\n named=False|'maybe'|True: 'maybe' is e.g., for function objects which\n doesn't need to name the arguments\n\n outer == operatorCast: annoying case, we should not take the params\n \"\"\"\n if outer: # always named\n if outer not in ('type', 'member', 'function',\n 'operatorCast', 'templateParam'):\n raise Exception('Internal error, unknown outer \"%s\".' % outer)\n if outer != 'operatorCast':\n assert named\n if outer in ('type', 'function'):\n # We allow type objects to just be a name.\n # Some functions don't have normal return types: constructors,\n # destrutors, cast operators\n prevErrors = []\n startPos = self.pos\n # first try without the type\n try:\n declSpecs = self._parse_decl_specs(outer=outer, typed=False)\n decl = self._parse_declarator(named=True, paramMode=outer,\n typed=False)\n self.assert_end()\n except DefinitionError as exUntyped:\n if outer == 'type':\n desc = \"If just a name\"\n elif outer == 'function':\n desc = \"If the function has no return type\"\n else:\n assert False\n prevErrors.append((exUntyped, desc))\n self.pos = startPos\n try:\n declSpecs = self._parse_decl_specs(outer=outer)\n decl = self._parse_declarator(named=True, paramMode=outer)\n except DefinitionError as exTyped:\n self.pos = startPos\n if outer == 'type':\n desc = \"If typedef-like declaration\"\n elif outer == 'function':\n desc = \"If the function has a return type\"\n else:\n assert False\n prevErrors.append((exTyped, desc))\n # Retain the else branch for easier debugging.\n # TODO: it would be nice to save the previous stacktrace\n # and output it here.\n if True:\n if outer == 'type':\n header = \"Type must be either just a name or a \"\n header += \"typedef-like declaration.\"\n elif outer == 'function':\n header = \"Error when parsing function declaration.\"\n else:\n assert False\n raise self._make_multi_error(prevErrors, header)\n else:\n # For testing purposes.\n # do it again to get the proper traceback (how do you\n # reliably save a traceback when an exception is\n # constructed?)\n self.pos = startPos\n typed = True\n declSpecs = self._parse_decl_specs(outer=outer, typed=typed)\n decl = self._parse_declarator(named=True, paramMode=outer,\n typed=typed)\n else:\n paramMode = 'type'\n if outer == 'member': # i.e., member\n named = True\n elif outer == 'operatorCast':\n paramMode = 'operatorCast'\n outer = None\n elif outer == 'templateParam':\n named = 'single'\n declSpecs = self._parse_decl_specs(outer=outer)\n decl = self._parse_declarator(named=named, paramMode=paramMode)\n return ASTType(declSpecs, decl)\n\n def _parse_type_with_init(\n self, named: Union[bool, str],\n outer: str) -> Union[ASTTypeWithInit, ASTTemplateParamConstrainedTypeWithInit]:\n if outer:\n assert outer in ('type', 'member', 'function', 'templateParam')\n type = self._parse_type(outer=outer, named=named)\n if outer != 'templateParam':\n init = self._parse_initializer(outer=outer)\n return ASTTypeWithInit(type, init)\n # it could also be a constrained type parameter, e.g., C T = int&\n pos = self.pos\n eExpr = None\n try:\n init = self._parse_initializer(outer=outer, allowFallback=False)\n # note: init may be None if there is no =\n if init is None:\n return ASTTypeWithInit(type, None)\n # we parsed an expression, so we must have a , or a >,\n # otherwise the expression didn't get everything\n self.skip_ws()\n if self.current_char != ',' and self.current_char != '>':\n # pretend it didn't happen\n self.pos = pos\n init = None\n else:\n # we assume that it was indeed an expression\n return ASTTypeWithInit(type, init)\n except DefinitionError as e:\n self.pos = pos\n eExpr = e\n if not self.skip_string(\"=\"):\n return ASTTypeWithInit(type, None)\n try:\n typeInit = self._parse_type(named=False, outer=None)\n return ASTTemplateParamConstrainedTypeWithInit(type, typeInit)\n except DefinitionError as eType:\n if eExpr is None:\n raise eType\n errs = []\n errs.append((eExpr, \"If default template argument is an expression\"))\n errs.append((eType, \"If default template argument is a type\"))\n msg = \"Error in non-type template parameter\"\n msg += \" or constrained template parameter.\"\n raise self._make_multi_error(errs, msg)\n\n def _parse_type_using(self) -> ASTTypeUsing:\n name = self._parse_nested_name()\n self.skip_ws()\n if not self.skip_string('='):\n return ASTTypeUsing(name, None)\n type = self._parse_type(False, None)\n return ASTTypeUsing(name, type)\n\n def _parse_concept(self) -> ASTConcept:\n nestedName = self._parse_nested_name()\n self.skip_ws()\n initializer = self._parse_initializer('member')\n return ASTConcept(nestedName, initializer)\n\n def _parse_class(self) -> ASTClass:\n name = self._parse_nested_name()\n self.skip_ws()\n final = self.skip_word_and_ws('final')\n bases = []\n self.skip_ws()\n if self.skip_string(':'):\n while 1:\n self.skip_ws()\n visibility = None\n virtual = False\n pack = False\n if self.skip_word_and_ws('virtual'):\n virtual = True\n if self.match(_visibility_re):\n visibility = self.matched_text\n self.skip_ws()\n if not virtual and self.skip_word_and_ws('virtual'):\n virtual = True\n baseName = self._parse_nested_name()\n self.skip_ws()\n pack = self.skip_string('...')\n bases.append(ASTBaseClass(baseName, visibility, virtual, pack))\n self.skip_ws()\n if self.skip_string(','):\n continue\n else:\n break\n return ASTClass(name, final, bases)\n\n def _parse_union(self) -> ASTUnion:\n name = self._parse_nested_name()\n return ASTUnion(name)\n\n def _parse_enum(self) -> ASTEnum:\n scoped = None # is set by CPPEnumObject\n self.skip_ws()\n name = self._parse_nested_name()\n self.skip_ws()\n underlyingType = None\n if self.skip_string(':'):\n underlyingType = self._parse_type(named=False)\n return ASTEnum(name, scoped, underlyingType)\n\n def _parse_enumerator(self) -> ASTEnumerator:\n name = self._parse_nested_name()\n self.skip_ws()\n init = None\n if self.skip_string('='):\n self.skip_ws()\n\n def parser() -> ASTExpression:\n return self._parse_constant_expression(inTemplate=False)\n initVal = self._parse_expression_fallback([], parser)\n init = ASTInitializer(initVal)\n return ASTEnumerator(name, init)\n\n # ==========================================================================\n\n def _parse_template_parameter_list(self) -> ASTTemplateParams:\n # only: '<' parameter-list '>'\n # we assume that 'template' has just been parsed\n templateParams = [] # type: List[ASTTemplateParam]\n self.skip_ws()\n if not self.skip_string(\"<\"):\n self.fail(\"Expected '<' after 'template'\")\n prevErrors = []\n while 1:\n self.skip_ws()\n if self.skip_word('template'):\n # declare a tenplate template parameter\n nestedParams = self._parse_template_parameter_list()\n else:\n nestedParams = None\n self.skip_ws()\n key = None\n if self.skip_word_and_ws('typename'):\n key = 'typename'\n elif self.skip_word_and_ws('class'):\n key = 'class'\n elif nestedParams:\n self.fail(\"Expected 'typename' or 'class' after \"\n \"template template parameter list.\")\n if key:\n # declare a type or template type parameter\n self.skip_ws()\n parameterPack = self.skip_string('...')\n self.skip_ws()\n if self.match(identifier_re):\n identifier = ASTIdentifier(self.matched_text)\n else:\n identifier = None\n self.skip_ws()\n if not parameterPack and self.skip_string('='):\n default = self._parse_type(named=False, outer=None)\n else:\n default = None\n data = ASTTemplateKeyParamPackIdDefault(key, identifier,\n parameterPack, default)\n if nestedParams:\n # template type\n templateParams.append(\n ASTTemplateParamTemplateType(nestedParams, data))\n else:\n # type\n templateParams.append(ASTTemplateParamType(data))\n else:\n # declare a non-type parameter, or constrained type parameter\n pos = self.pos\n try:\n param = self._parse_type_with_init('maybe', 'templateParam')\n templateParams.append(ASTTemplateParamNonType(param))\n except DefinitionError as e:\n msg = \"If non-type template parameter or constrained template parameter\"\n prevErrors.append((e, msg))\n self.pos = pos\n self.skip_ws()\n if self.skip_string('>'):\n return ASTTemplateParams(templateParams)\n elif self.skip_string(','):\n prevErrors = []\n continue\n else:\n header = \"Error in template parameter list.\"\n try:\n self.fail('Expected \"=\", \",\", or \">\".')\n except DefinitionError as e:\n prevErrors.append((e, \"\"))\n raise self._make_multi_error(prevErrors, header)\n\n def _parse_template_introduction(self) -> ASTTemplateIntroduction:\n pos = self.pos\n try:\n concept = self._parse_nested_name()\n except Exception:\n self.pos = pos\n return None\n self.skip_ws()\n if not self.skip_string('{'):\n self.pos = pos\n return None\n\n # for sure it must be a template introduction now\n params = []\n while 1:\n self.skip_ws()\n parameterPack = self.skip_string('...')\n self.skip_ws()\n if not self.match(identifier_re):\n self.fail(\"Expected identifier in template introduction list.\")\n txt_identifier = self.matched_text\n # make sure there isn't a keyword\n if txt_identifier in _keywords:\n self.fail(\"Expected identifier in template introduction list, \"\n \"got keyword: %s\" % txt_identifier)\n identifier = ASTIdentifier(txt_identifier)\n params.append(ASTTemplateIntroductionParameter(identifier, parameterPack))\n\n self.skip_ws()\n if self.skip_string('}'):\n break\n elif self.skip_string(','):\n continue\n else:\n self.fail(\"Error in template introduction list. \"\n 'Expected \",\", or \"}\".')\n return ASTTemplateIntroduction(concept, params)\n\n def _parse_template_declaration_prefix(self, objectType: str\n ) -> ASTTemplateDeclarationPrefix:\n templates = [] # type: List[Union[ASTTemplateParams, ASTTemplateIntroduction]]\n while 1:\n self.skip_ws()\n # the saved position is only used to provide a better error message\n params = None # type: Union[ASTTemplateParams, ASTTemplateIntroduction]\n pos = self.pos\n if self.skip_word(\"template\"):\n try:\n params = self._parse_template_parameter_list()\n except DefinitionError as e:\n if objectType == 'member' and len(templates) == 0:\n return ASTTemplateDeclarationPrefix(None)\n else:\n raise e\n else:\n params = self._parse_template_introduction()\n if not params:\n break\n if objectType == 'concept' and len(templates) > 0:\n self.pos = pos\n self.fail(\"More than 1 template parameter list for concept.\")\n templates.append(params)\n if len(templates) == 0 and objectType == 'concept':\n self.fail('Missing template parameter list for concept.')\n if len(templates) == 0:\n return None\n else:\n return ASTTemplateDeclarationPrefix(templates)\n\n def _check_template_consistency(self, nestedName: ASTNestedName,\n templatePrefix: ASTTemplateDeclarationPrefix,\n fullSpecShorthand: bool, isMember: bool = False\n ) -> ASTTemplateDeclarationPrefix:\n numArgs = nestedName.num_templates()\n isMemberInstantiation = False\n if not templatePrefix:\n numParams = 0\n else:\n if isMember and templatePrefix.templates is None:\n numParams = 0\n isMemberInstantiation = True\n else:\n numParams = len(templatePrefix.templates)\n if numArgs + 1 < numParams:\n self.fail(\"Too few template argument lists comapred to parameter\"\n \" lists. Argument lists: %d, Parameter lists: %d.\"\n % (numArgs, numParams))\n if numArgs > numParams:\n numExtra = numArgs - numParams\n if not fullSpecShorthand and not isMemberInstantiation:\n msg = \"Too many template argument lists compared to parameter\" \\\n \" lists. Argument lists: %d, Parameter lists: %d,\" \\\n \" Extra empty parameters lists prepended: %d.\" \\\n % (numArgs, numParams, numExtra)\n msg += \" Declaration:\\n\\t\"\n if templatePrefix:\n msg += \"%s\\n\\t\" % templatePrefix\n msg += str(nestedName)\n self.warn(msg)\n\n newTemplates = [] # type: List[Union[ASTTemplateParams, ASTTemplateIntroduction]]\n for i in range(numExtra):\n newTemplates.append(ASTTemplateParams([]))\n if templatePrefix and not isMemberInstantiation:\n newTemplates.extend(templatePrefix.templates)\n templatePrefix = ASTTemplateDeclarationPrefix(newTemplates)\n return templatePrefix\n\n def parse_declaration(self, objectType: str, directiveType: str) -> ASTDeclaration:\n if objectType not in ('class', 'union', 'function', 'member', 'type',\n 'concept', 'enum', 'enumerator'):\n raise Exception('Internal error, unknown objectType \"%s\".' % objectType)\n if directiveType not in ('class', 'struct', 'union', 'function', 'member', 'var',\n 'type', 'concept',\n 'enum', 'enum-struct', 'enum-class', 'enumerator'):\n raise Exception('Internal error, unknown directiveType \"%s\".' % directiveType)\n visibility = None\n templatePrefix = None\n declaration = None # type: Any\n\n self.skip_ws()\n if self.match(_visibility_re):\n visibility = self.matched_text\n\n if objectType in ('type', 'concept', 'member', 'function', 'class'):\n templatePrefix = self._parse_template_declaration_prefix(objectType)\n\n if objectType == 'type':\n prevErrors = []\n pos = self.pos\n try:\n if not templatePrefix:\n declaration = self._parse_type(named=True, outer='type')\n except DefinitionError as e:\n prevErrors.append((e, \"If typedef-like declaration\"))\n self.pos = pos\n pos = self.pos\n try:\n if not declaration:\n declaration = self._parse_type_using()\n except DefinitionError as e:\n self.pos = pos\n prevErrors.append((e, \"If type alias or template alias\"))\n header = \"Error in type declaration.\"\n raise self._make_multi_error(prevErrors, header)\n elif objectType == 'concept':\n declaration = self._parse_concept()\n elif objectType == 'member':\n declaration = self._parse_type_with_init(named=True, outer='member')\n elif objectType == 'function':\n declaration = self._parse_type(named=True, outer='function')\n elif objectType == 'class':\n declaration = self._parse_class()\n elif objectType == 'union':\n declaration = self._parse_union()\n elif objectType == 'enum':\n declaration = self._parse_enum()\n elif objectType == 'enumerator':\n declaration = self._parse_enumerator()\n else:\n assert False\n templatePrefix = self._check_template_consistency(declaration.name,\n templatePrefix,\n fullSpecShorthand=False,\n isMember=objectType == 'member')\n return ASTDeclaration(objectType, directiveType, visibility,\n templatePrefix, declaration)\n\n def parse_namespace_object(self) -> ASTNamespace:\n templatePrefix = self._parse_template_declaration_prefix(objectType=\"namespace\")\n name = self._parse_nested_name()\n templatePrefix = self._check_template_consistency(name, templatePrefix,\n fullSpecShorthand=False)\n res = ASTNamespace(name, templatePrefix)\n res.objectType = 'namespace' # type: ignore\n return res\n\n def parse_xref_object(self) -> Tuple[Union[ASTNamespace, ASTDeclaration], bool]:\n pos = self.pos\n try:\n templatePrefix = self._parse_template_declaration_prefix(objectType=\"xref\")\n name = self._parse_nested_name()\n # if there are '()' left, just skip them\n self.skip_ws()\n self.skip_string('()')\n self.assert_end()\n templatePrefix = self._check_template_consistency(name, templatePrefix,\n fullSpecShorthand=True)\n res1 = ASTNamespace(name, templatePrefix)\n res1.objectType = 'xref' # type: ignore\n return res1, True\n except DefinitionError as e1:\n try:\n self.pos = pos\n res2 = self.parse_declaration('function', 'function')\n # if there are '()' left, just skip them\n self.skip_ws()\n self.skip_string('()')\n self.assert_end()\n return res2, False\n except DefinitionError as e2:\n errs = []\n errs.append((e1, \"If shorthand ref\"))\n errs.append((e2, \"If full function ref\"))\n msg = \"Error in cross-reference.\"\n raise self._make_multi_error(errs, msg)\n\n def parse_expression(self) -> Union[ASTExpression, ASTType]:\n pos = self.pos\n try:\n expr = self._parse_expression()\n self.skip_ws()\n self.assert_end()\n return expr\n except DefinitionError as exExpr:\n self.pos = pos\n try:\n typ = self._parse_type(False)\n self.skip_ws()\n self.assert_end()\n return typ\n except DefinitionError as exType:\n header = \"Error when parsing (type) expression.\"\n errs = []\n errs.append((exExpr, \"If expression\"))\n errs.append((exType, \"If type\"))\n raise self._make_multi_error(errs, header)\n\n\ndef _make_phony_error_name() -> ASTNestedName:\n nne = ASTNestedNameElement(ASTIdentifier(\"PhonyNameDueToError\"), None)\n return ASTNestedName([nne], [False], rooted=False)\n\n\nclass CPPObject(ObjectDescription):\n \"\"\"Description of a C++ language object.\"\"\"\n\n doc_field_types = [\n GroupedField('parameter', label=_('Parameters'),\n names=('param', 'parameter', 'arg', 'argument'),\n can_collapse=True),\n GroupedField('template parameter', label=_('Template Parameters'),\n names=('tparam', 'template parameter'),\n can_collapse=True),\n GroupedField('exceptions', label=_('Throws'), rolename='cpp:class',\n names=('throws', 'throw', 'exception'),\n can_collapse=True),\n Field('returnvalue', label=_('Returns'), has_arg=False,\n names=('returns', 'return')),\n ]\n\n option_spec = dict(ObjectDescription.option_spec)\n option_spec['tparam-line-spec'] = directives.flag\n\n def _add_enumerator_to_parent(self, ast: ASTDeclaration) -> None:\n assert ast.objectType == 'enumerator'\n # find the parent, if it exists && is an enum\n # && it's unscoped,\n # then add the name to the parent scope\n symbol = ast.symbol\n assert symbol\n assert symbol.identOrOp is not None\n assert symbol.templateParams is None\n assert symbol.templateArgs is None\n parentSymbol = symbol.parent\n assert parentSymbol\n if parentSymbol.parent is None:\n # TODO: we could warn, but it is somewhat equivalent to unscoped\n # enums, without the enum\n return # no parent\n parentDecl = parentSymbol.declaration\n if parentDecl is None:\n # the parent is not explicitly declared\n # TODO: we could warn, but it could be a style to just assume\n # enumerator parents to be scoped\n return\n if parentDecl.objectType != 'enum':\n # TODO: maybe issue a warning, enumerators in non-enums is weird,\n # but it is somewhat equivalent to unscoped enums, without the enum\n return\n if parentDecl.directiveType != 'enum':\n return\n\n targetSymbol = parentSymbol.parent\n s = targetSymbol.find_identifier(symbol.identOrOp, matchSelf=False, recurseInAnon=True,\n searchInSiblings=False)\n if s is not None:\n # something is already declared with that name\n return\n declClone = symbol.declaration.clone()\n declClone.enumeratorScopedSymbol = symbol\n Symbol(parent=targetSymbol, identOrOp=symbol.identOrOp,\n templateParams=None, templateArgs=None,\n declaration=declClone,\n docname=self.env.docname)\n\n def add_target_and_index(self, ast: ASTDeclaration, sig: str,\n signode: TextElement) -> None:\n # general note: name must be lstrip(':')'ed, to remove \"::\"\n ids = []\n for i in range(1, _max_id + 1):\n try:\n id = ast.get_id(version=i)\n ids.append(id)\n except NoOldIdError:\n assert i < _max_id\n # let's keep the newest first\n ids = list(reversed(ids))\n newestId = ids[0]\n assert newestId # shouldn't be None\n if not re.compile(r'^[a-zA-Z0-9_]*$').match(newestId):\n logger.warning('Index id generation for C++ object \"%s\" failed, please '\n 'report as bug (id=%s).', ast, newestId,\n location=self.get_source_info())\n\n name = ast.symbol.get_full_nested_name().get_display_string().lstrip(':')\n # Add index entry, but not if it's a declaration inside a concept\n isInConcept = False\n s = ast.symbol.parent\n while s is not None:\n decl = s.declaration\n s = s.parent\n if decl is None:\n continue\n if decl.objectType == 'concept':\n isInConcept = True\n break\n if not isInConcept:\n strippedName = name\n for prefix in self.env.config.cpp_index_common_prefix:\n if name.startswith(prefix):\n strippedName = strippedName[len(prefix):]\n break\n indexText = self.get_index_text(strippedName)\n self.indexnode['entries'].append(('single', indexText, newestId, '', None))\n\n if newestId not in self.state.document.ids:\n # if the name is not unique, the first one will win\n names = self.env.domaindata['cpp']['names']\n if name not in names:\n names[name] = ast.symbol.docname\n # always add the newest id\n assert newestId\n signode['ids'].append(newestId)\n # only add compatibility ids when there are no conflicts\n for id in ids[1:]:\n if not id: # is None when the element didn't exist in that version\n continue\n if id not in self.state.document.ids:\n signode['ids'].append(id)\n self.state.document.note_explicit_target(signode)\n\n @property\n def object_type(self) -> str:\n raise NotImplementedError()\n\n @property\n def display_object_type(self) -> str:\n return self.object_type\n\n def get_index_text(self, name: str) -> str:\n return _('%s (C++ %s)') % (name, self.display_object_type)\n\n def parse_definition(self, parser: DefinitionParser) -> ASTDeclaration:\n return parser.parse_declaration(self.object_type, self.objtype)\n\n def describe_signature(self, signode: desc_signature,\n ast: ASTDeclaration, options: Dict) -> None:\n ast.describe_signature(signode, 'lastIsName', self.env, options)\n\n def run(self) -> List[Node]:\n env = self.state.document.settings.env # from ObjectDescription.run\n if 'cpp:parent_symbol' not in env.temp_data:\n root = env.domaindata['cpp']['root_symbol']\n env.temp_data['cpp:parent_symbol'] = root\n env.ref_context['cpp:parent_key'] = root.get_lookup_key()\n\n # The lookup keys assume that no nested scopes exists inside overloaded functions.\n # (see also #5191)\n # Example:\n # .. cpp:function:: void f(int)\n # .. cpp:function:: void f(double)\n #\n # .. cpp:function:: void g()\n #\n # :cpp:any:`boom`\n #\n # So we disallow any signatures inside functions.\n parentSymbol = env.temp_data['cpp:parent_symbol']\n parentDecl = parentSymbol.declaration\n if parentDecl is not None and parentDecl.objectType == 'function':\n logger.warning(\"C++ declarations inside functions are not supported.\" +\n \" Parent function is \" +\n str(parentSymbol.get_full_nested_name()),\n location=self.get_source_info())\n name = _make_phony_error_name()\n symbol = parentSymbol.add_name(name)\n env.temp_data['cpp:last_symbol'] = symbol\n return []\n # When multiple declarations are made in the same directive\n # they need to know about each other to provide symbol lookup for function parameters.\n # We use last_symbol to store the latest added declaration in a directive.\n env.temp_data['cpp:last_symbol'] = None\n return super().run()\n\n def handle_signature(self, sig: str, signode: desc_signature) -> ASTDeclaration:\n parentSymbol = self.env.temp_data['cpp:parent_symbol']\n\n parser = DefinitionParser(sig, location=signode, config=self.env.config)\n try:\n ast = self.parse_definition(parser)\n parser.assert_end()\n except DefinitionError as e:\n logger.warning(e, location=signode)\n # It is easier to assume some phony name than handling the error in\n # the possibly inner declarations.\n name = _make_phony_error_name()\n symbol = parentSymbol.add_name(name)\n self.env.temp_data['cpp:last_symbol'] = symbol\n raise ValueError\n\n try:\n symbol = parentSymbol.add_declaration(ast, docname=self.env.docname)\n # append the new declaration to the sibling list\n assert symbol.siblingAbove is None\n assert symbol.siblingBelow is None\n symbol.siblingAbove = self.env.temp_data['cpp:last_symbol']\n if symbol.siblingAbove is not None:\n assert symbol.siblingAbove.siblingBelow is None\n symbol.siblingAbove.siblingBelow = symbol\n self.env.temp_data['cpp:last_symbol'] = symbol\n except _DuplicateSymbolError as e:\n # Assume we are actually in the old symbol,\n # instead of the newly created duplicate.\n self.env.temp_data['cpp:last_symbol'] = e.symbol\n logger.warning(\"Duplicate declaration, %s\", sig, location=signode)\n\n if ast.objectType == 'enumerator':\n self._add_enumerator_to_parent(ast)\n\n # note: handle_signature may be called multiple time per directive,\n # if it has multiple signatures, so don't mess with the original options.\n options = dict(self.options)\n options['tparam-line-spec'] = 'tparam-line-spec' in self.options\n self.describe_signature(signode, ast, options)\n return ast\n\n def before_content(self) -> None:\n lastSymbol = self.env.temp_data['cpp:last_symbol'] # type: Symbol\n assert lastSymbol\n self.oldParentSymbol = self.env.temp_data['cpp:parent_symbol']\n self.oldParentKey = self.env.ref_context['cpp:parent_key'] # type: LookupKey\n self.env.temp_data['cpp:parent_symbol'] = lastSymbol\n self.env.ref_context['cpp:parent_key'] = lastSymbol.get_lookup_key()\n\n def after_content(self) -> None:\n self.env.temp_data['cpp:parent_symbol'] = self.oldParentSymbol\n self.env.ref_context['cpp:parent_key'] = self.oldParentKey\n\n\nclass CPPTypeObject(CPPObject):\n object_type = 'type'\n\n\nclass CPPConceptObject(CPPObject):\n object_type = 'concept'\n\n\nclass CPPMemberObject(CPPObject):\n object_type = 'member'\n\n\nclass CPPFunctionObject(CPPObject):\n object_type = 'function'\n\n\nclass CPPClassObject(CPPObject):\n object_type = 'class'\n\n @property\n def display_object_type(self) -> str:\n # the distinction between class and struct is only cosmetic\n assert self.objtype in ('class', 'struct')\n return self.objtype\n\n\nclass CPPUnionObject(CPPObject):\n object_type = 'union'\n\n\nclass CPPEnumObject(CPPObject):\n object_type = 'enum'\n\n\nclass CPPEnumeratorObject(CPPObject):\n object_type = 'enumerator'\n\n\nclass CPPNamespaceObject(SphinxDirective):\n \"\"\"\n This directive is just to tell Sphinx that we're documenting stuff in\n namespace foo.\n \"\"\"\n\n has_content = False\n required_arguments = 1\n optional_arguments = 0\n final_argument_whitespace = True\n option_spec = {} # type: Dict\n\n def run(self) -> List[Node]:\n rootSymbol = self.env.domaindata['cpp']['root_symbol']\n if self.arguments[0].strip() in ('NULL', '0', 'nullptr'):\n symbol = rootSymbol\n stack = [] # type: List[Symbol]\n else:\n parser = DefinitionParser(self.arguments[0],\n location=self.get_source_info(),\n config=self.config)\n try:\n ast = parser.parse_namespace_object()\n parser.assert_end()\n except DefinitionError as e:\n logger.warning(e, location=self.get_source_info())\n name = _make_phony_error_name()\n ast = ASTNamespace(name, None)\n symbol = rootSymbol.add_name(ast.nestedName, ast.templatePrefix)\n stack = [symbol]\n self.env.temp_data['cpp:parent_symbol'] = symbol\n self.env.temp_data['cpp:namespace_stack'] = stack\n self.env.ref_context['cpp:parent_key'] = symbol.get_lookup_key()\n return []\n\n\nclass CPPNamespacePushObject(SphinxDirective):\n has_content = False\n required_arguments = 1\n optional_arguments = 0\n final_argument_whitespace = True\n option_spec = {} # type: Dict\n\n def run(self) -> List[Node]:\n if self.arguments[0].strip() in ('NULL', '0', 'nullptr'):\n return []\n parser = DefinitionParser(self.arguments[0],\n location=self.get_source_info(),\n config=self.config)\n try:\n ast = parser.parse_namespace_object()\n parser.assert_end()\n except DefinitionError as e:\n logger.warning(e, location=self.get_source_info())\n name = _make_phony_error_name()\n ast = ASTNamespace(name, None)\n oldParent = self.env.temp_data.get('cpp:parent_symbol', None)\n if not oldParent:\n oldParent = self.env.domaindata['cpp']['root_symbol']\n symbol = oldParent.add_name(ast.nestedName, ast.templatePrefix)\n stack = self.env.temp_data.get('cpp:namespace_stack', [])\n stack.append(symbol)\n self.env.temp_data['cpp:parent_symbol'] = symbol\n self.env.temp_data['cpp:namespace_stack'] = stack\n self.env.ref_context['cpp:parent_key'] = symbol.get_lookup_key()\n return []\n\n\nclass CPPNamespacePopObject(SphinxDirective):\n has_content = False\n required_arguments = 0\n optional_arguments = 0\n final_argument_whitespace = True\n option_spec = {} # type: Dict\n\n def run(self) -> List[Node]:\n stack = self.env.temp_data.get('cpp:namespace_stack', None)\n if not stack or len(stack) == 0:\n logger.warning(\"C++ namespace pop on empty stack. Defaulting to gobal scope.\",\n location=self.get_source_info())\n stack = []\n else:\n stack.pop()\n if len(stack) > 0:\n symbol = stack[-1]\n else:\n symbol = self.env.domaindata['cpp']['root_symbol']\n self.env.temp_data['cpp:parent_symbol'] = symbol\n self.env.temp_data['cpp:namespace_stack'] = stack\n self.env.ref_context['cpp:parent_key'] = symbol.get_lookup_key()\n return []\n\n\nclass AliasNode(nodes.Element):\n def __init__(self, sig: str, env: \"BuildEnvironment\" = None,\n parentKey: LookupKey = None) -> None:\n super().__init__()\n self.sig = sig\n if env is not None:\n if 'cpp:parent_symbol' not in env.temp_data:\n root = env.domaindata['cpp']['root_symbol']\n env.temp_data['cpp:parent_symbol'] = root\n self.parentKey = env.temp_data['cpp:parent_symbol'].get_lookup_key()\n else:\n assert parentKey is not None\n self.parentKey = parentKey\n\n def copy(self: T) -> T:\n return self.__class__(self.sig, env=None, parentKey=self.parentKey) # type: ignore\n\n\nclass AliasTransform(SphinxTransform):\n default_priority = ReferencesResolver.default_priority - 1\n\n def apply(self, **kwargs: Any) -> None:\n for node in self.document.traverse(AliasNode):\n sig = node.sig\n parentKey = node.parentKey\n try:\n parser = DefinitionParser(sig, location=node,\n config=self.env.config)\n ast, isShorthand = parser.parse_xref_object()\n parser.assert_end()\n except DefinitionError as e:\n logger.warning(e, location=node)\n ast, isShorthand = None, None\n\n if ast is None:\n # could not be parsed, so stop here\n signode = addnodes.desc_signature(sig, '')\n signode.clear()\n signode += addnodes.desc_name(sig, sig)\n node.replace_self(signode)\n continue\n\n rootSymbol = self.env.domains['cpp'].data['root_symbol'] # type: Symbol\n parentSymbol = rootSymbol.direct_lookup(parentKey) # type: Symbol\n if not parentSymbol:\n print(\"Target: \", sig)\n print(\"ParentKey: \", parentKey)\n print(rootSymbol.dump(1))\n assert parentSymbol # should be there\n\n symbols = [] # type: List[Symbol]\n if isShorthand:\n assert isinstance(ast, ASTNamespace)\n ns = ast\n name = ns.nestedName\n if ns.templatePrefix:\n templateDecls = ns.templatePrefix.templates\n else:\n templateDecls = []\n symbols, failReason = parentSymbol.find_name(\n nestedName=name,\n templateDecls=templateDecls,\n typ='any',\n templateShorthand=True,\n matchSelf=True, recurseInAnon=True,\n searchInSiblings=False)\n if symbols is None:\n symbols = []\n else:\n assert isinstance(ast, ASTDeclaration)\n decl = ast\n name = decl.name\n s = parentSymbol.find_declaration(decl, 'any',\n templateShorthand=True,\n matchSelf=True, recurseInAnon=True)\n if s is not None:\n symbols.append(s)\n\n symbols = [s for s in symbols if s.declaration is not None]\n\n if len(symbols) == 0:\n signode = addnodes.desc_signature(sig, '')\n node.append(signode)\n signode.clear()\n signode += addnodes.desc_name(sig, sig)\n\n logger.warning(\"Could not find C++ declaration for alias '%s'.\" % ast,\n location=node)\n node.replace_self(signode)\n else:\n nodes = []\n options = dict()\n options['tparam-line-spec'] = False\n for s in symbols:\n signode = addnodes.desc_signature(sig, '')\n nodes.append(signode)\n s.declaration.describe_signature(signode, 'markName', self.env, options)\n node.replace_self(nodes)\n\n\nclass CPPAliasObject(ObjectDescription):\n option_spec = {} # type: Dict\n\n def run(self) -> List[Node]:\n \"\"\"\n On purpose this doesn't call the ObjectDescription version, but is based on it.\n Each alias signature may expand into multiple real signatures (an overload set).\n The code is therefore based on the ObjectDescription version.\n \"\"\"\n if ':' in self.name:\n self.domain, self.objtype = self.name.split(':', 1)\n else:\n self.domain, self.objtype = '', self.name\n\n node = addnodes.desc()\n node.document = self.state.document\n node['domain'] = self.domain\n # 'desctype' is a backwards compatible attribute\n node['objtype'] = node['desctype'] = self.objtype\n node['noindex'] = True\n\n self.names = [] # type: List[str]\n signatures = self.get_signatures()\n for i, sig in enumerate(signatures):\n node.append(AliasNode(sig, env=self.env))\n\n contentnode = addnodes.desc_content()\n node.append(contentnode)\n self.before_content()\n self.state.nested_parse(self.content, self.content_offset, contentnode)\n self.env.temp_data['object'] = None\n self.after_content()\n return [node]\n\n\nclass CPPXRefRole(XRefRole):\n def process_link(self, env: BuildEnvironment, refnode: Element, has_explicit_title: bool,\n title: str, target: str) -> Tuple[str, str]:\n refnode.attributes.update(env.ref_context)\n\n if not has_explicit_title:\n # major hax: replace anon names via simple string manipulation.\n # Can this actually fail?\n title = anon_identifier_re.sub(\"[anonymous]\", str(title))\n\n if refnode['reftype'] == 'any':\n # Assume the removal part of fix_parens for :any: refs.\n # The addition part is done with the reference is resolved.\n if not has_explicit_title and title.endswith('()'):\n title = title[:-2]\n if target.endswith('()'):\n target = target[:-2]\n # TODO: should this really be here?\n if not has_explicit_title:\n target = target.lstrip('~') # only has a meaning for the title\n # if the first character is a tilde, don't display the module/class\n # parts of the contents\n if title[:1] == '~':\n title = title[1:]\n dcolon = title.rfind('::')\n if dcolon != -1:\n title = title[dcolon + 2:]\n return title, target\n\n\nclass CPPExprRole(SphinxRole):\n def __init__(self, asCode: bool) -> None:\n super().__init__()\n if asCode:\n # render the expression as inline code\n self.class_type = 'cpp-expr'\n self.node_type = nodes.literal # type: Type[TextElement]\n else:\n # render the expression as inline text\n self.class_type = 'cpp-texpr'\n self.node_type = nodes.inline\n\n def run(self) -> Tuple[List[Node], List[system_message]]:\n text = self.text.replace('\\n', ' ')\n parser = DefinitionParser(text,\n location=self.get_source_info(),\n config=self.config)\n # attempt to mimic XRefRole classes, except that...\n classes = ['xref', 'cpp', self.class_type]\n try:\n ast = parser.parse_expression()\n except DefinitionError as ex:\n logger.warning('Unparseable C++ expression: %r\\n%s', text, ex,\n location=self.get_source_info())\n # see below\n return [self.node_type(text, text, classes=classes)], []\n parentSymbol = self.env.temp_data.get('cpp:parent_symbol', None)\n if parentSymbol is None:\n parentSymbol = self.env.domaindata['cpp']['root_symbol']\n # ...most if not all of these classes should really apply to the individual references,\n # not the container node\n signode = self.node_type(classes=classes)\n ast.describe_signature(signode, 'markType', self.env, parentSymbol)\n return [signode], []\n\n\nclass CPPDomain(Domain):\n \"\"\"C++ language domain.\n\n There are two 'object type' attributes being used::\n\n - Each object created from directives gets an assigned .objtype from ObjectDescription.run.\n This is simply the directive name.\n - Each declaration (see the distinction in the directives dict below) has a nested .ast of\n type ASTDeclaration. That object has .objectType which corresponds to the keys in the\n object_types dict below. They are the core different types of declarations in C++ that\n one can document.\n \"\"\"\n name = 'cpp'\n label = 'C++'\n object_types = {\n 'class': ObjType(_('class'), 'class', 'type', 'identifier'),\n 'union': ObjType(_('union'), 'union', 'type', 'identifier'),\n 'function': ObjType(_('function'), 'function', 'func', 'type', 'identifier'),\n 'member': ObjType(_('member'), 'member', 'var'),\n 'type': ObjType(_('type'), 'type', 'identifier'),\n 'concept': ObjType(_('concept'), 'concept', 'identifier'),\n 'enum': ObjType(_('enum'), 'enum', 'type', 'identifier'),\n 'enumerator': ObjType(_('enumerator'), 'enumerator')\n }\n\n directives = {\n # declarations\n 'class': CPPClassObject,\n 'struct': CPPClassObject,\n 'union': CPPUnionObject,\n 'function': CPPFunctionObject,\n 'member': CPPMemberObject,\n 'var': CPPMemberObject,\n 'type': CPPTypeObject,\n 'concept': CPPConceptObject,\n 'enum': CPPEnumObject,\n 'enum-struct': CPPEnumObject,\n 'enum-class': CPPEnumObject,\n 'enumerator': CPPEnumeratorObject,\n # scope control\n 'namespace': CPPNamespaceObject,\n 'namespace-push': CPPNamespacePushObject,\n 'namespace-pop': CPPNamespacePopObject,\n # other\n 'alias': CPPAliasObject\n }\n roles = {\n 'any': CPPXRefRole(),\n 'class': CPPXRefRole(),\n 'struct': CPPXRefRole(),\n 'union': CPPXRefRole(),\n 'func': CPPXRefRole(fix_parens=True),\n 'member': CPPXRefRole(),\n 'var': CPPXRefRole(),\n 'type': CPPXRefRole(),\n 'concept': CPPXRefRole(),\n 'enum': CPPXRefRole(),\n 'enumerator': CPPXRefRole(),\n 'expr': CPPExprRole(asCode=True),\n 'texpr': CPPExprRole(asCode=False)\n }\n initial_data = {\n 'root_symbol': Symbol(None, None, None, None, None, None),\n 'names': {} # full name for indexing -> docname\n }\n\n def clear_doc(self, docname: str) -> None:\n if Symbol.debug_show_tree:\n print(\"clear_doc:\", docname)\n print(\"\\tbefore:\")\n print(self.data['root_symbol'].dump(1))\n print(\"\\tbefore end\")\n\n rootSymbol = self.data['root_symbol']\n rootSymbol.clear_doc(docname)\n\n if Symbol.debug_show_tree:\n print(\"\\tafter:\")\n print(self.data['root_symbol'].dump(1))\n print(\"\\tafter end\")\n print(\"clear_doc end:\", docname)\n for name, nDocname in list(self.data['names'].items()):\n if nDocname == docname:\n del self.data['names'][name]\n\n def process_doc(self, env: BuildEnvironment, docname: str,\n document: nodes.document) -> None:\n if Symbol.debug_show_tree:\n print(\"process_doc:\", docname)\n print(self.data['root_symbol'].dump(0))\n print(\"process_doc end:\", docname)\n\n def process_field_xref(self, pnode: pending_xref) -> None:\n pnode.attributes.update(self.env.ref_context)\n\n def merge_domaindata(self, docnames: List[str], otherdata: Dict) -> None:\n if Symbol.debug_show_tree:\n print(\"merge_domaindata:\")\n print(\"\\tself:\")\n print(self.data['root_symbol'].dump(1))\n print(\"\\tself end\")\n print(\"\\tother:\")\n print(otherdata['root_symbol'].dump(1))\n print(\"\\tother end\")\n\n self.data['root_symbol'].merge_with(otherdata['root_symbol'],\n docnames, self.env)\n ourNames = self.data['names']\n for name, docname in otherdata['names'].items():\n if docname in docnames:\n if name in ourNames:\n msg = __(\"Duplicate declaration, also defined in '%s'.\\n\"\n \"Name of declaration is '%s'.\")\n msg = msg % (ourNames[name], name)\n logger.warning(msg, location=docname)\n else:\n ourNames[name] = docname\n if Symbol.debug_show_tree:\n print(\"\\tresult:\")\n print(self.data['root_symbol'].dump(1))\n print(\"\\tresult end\")\n print(\"merge_domaindata end\")\n\n def _resolve_xref_inner(self, env: BuildEnvironment, fromdocname: str, builder: Builder,\n typ: str, target: str, node: pending_xref,\n contnode: Element) -> Tuple[Element, str]:\n # add parens again for those that could be functions\n if typ == 'any' or typ == 'func':\n target += '()'\n parser = DefinitionParser(target, location=node, config=env.config)\n try:\n ast, isShorthand = parser.parse_xref_object()\n except DefinitionError as e:\n # as arg to stop flake8 from complaining\n def findWarning(e: Exception) -> Tuple[str, Exception]:\n if typ != 'any' and typ != 'func':\n return target, e\n # hax on top of the paren hax to try to get correct errors\n parser2 = DefinitionParser(target[:-2],\n location=node,\n config=env.config)\n try:\n parser2.parse_xref_object()\n except DefinitionError as e2:\n return target[:-2], e2\n # strange, that we don't get the error now, use the original\n return target, e\n t, ex = findWarning(e)\n logger.warning('Unparseable C++ cross-reference: %r\\n%s', t, ex,\n location=node)\n return None, None\n parentKey = node.get(\"cpp:parent_key\", None) # type: LookupKey\n rootSymbol = self.data['root_symbol']\n if parentKey:\n parentSymbol = rootSymbol.direct_lookup(parentKey) # type: Symbol\n if not parentSymbol:\n print(\"Target: \", target)\n print(\"ParentKey: \", parentKey.data)\n print(rootSymbol.dump(1))\n assert parentSymbol # should be there\n else:\n parentSymbol = rootSymbol\n\n if isShorthand:\n assert isinstance(ast, ASTNamespace)\n ns = ast\n name = ns.nestedName\n if ns.templatePrefix:\n templateDecls = ns.templatePrefix.templates\n else:\n templateDecls = []\n # let's be conservative with the sibling lookup for now\n searchInSiblings = (not name.rooted) and len(name.names) == 1\n symbols, failReason = parentSymbol.find_name(\n name, templateDecls, typ,\n templateShorthand=True,\n matchSelf=True, recurseInAnon=True,\n searchInSiblings=searchInSiblings)\n if symbols is None:\n if typ == 'identifier':\n if failReason == 'templateParamInQualified':\n # this is an xref we created as part of a signature,\n # so don't warn for names nested in template parameters\n raise NoUri(str(name), typ)\n s = None\n else:\n # just refer to the arbitrarily first symbol\n s = symbols[0]\n else:\n assert isinstance(ast, ASTDeclaration)\n decl = ast\n name = decl.name\n s = parentSymbol.find_declaration(decl, typ,\n templateShorthand=True,\n matchSelf=True, recurseInAnon=True)\n if s is None or s.declaration is None:\n txtName = str(name)\n if txtName.startswith('std::') or txtName == 'std':\n raise NoUri(txtName, typ)\n return None, None\n\n if typ.startswith('cpp:'):\n typ = typ[4:]\n origTyp = typ\n if typ == 'func':\n typ = 'function'\n if typ == 'struct':\n typ = 'class'\n declTyp = s.declaration.objectType\n\n def checkType() -> bool:\n if typ == 'any' or typ == 'identifier':\n return True\n if declTyp == 'templateParam':\n # TODO: perhaps this should be strengthened one day\n return True\n if declTyp == 'functionParam':\n if typ == 'var' or typ == 'member':\n return True\n objtypes = self.objtypes_for_role(typ)\n if objtypes:\n return declTyp in objtypes\n print(\"Type is %s (originally: %s), declType is %s\" % (typ, origTyp, declTyp))\n assert False\n if not checkType():\n logger.warning(\"cpp:%s targets a %s (%s).\",\n origTyp, s.declaration.objectType,\n s.get_full_nested_name(),\n location=node)\n\n declaration = s.declaration\n if isShorthand:\n fullNestedName = s.get_full_nested_name()\n displayName = fullNestedName.get_display_string().lstrip(':')\n else:\n displayName = decl.get_display_string()\n docname = s.docname\n assert docname\n\n # the non-identifier refs are cross-references, which should be processed:\n # - fix parenthesis due to operator() and add_function_parentheses\n if typ != \"identifier\":\n title = contnode.pop(0).astext()\n # If it's operator(), we need to add '()' if explicit function parens\n # are requested. Then the Sphinx machinery will add another pair.\n # Also, if it's an 'any' ref that resolves to a function, we need to add\n # parens as well.\n # However, if it's a non-shorthand function ref, for a function that\n # takes no arguments, then we may need to add parens again as well.\n addParen = 0\n if not node.get('refexplicit', False) and declaration.objectType == 'function':\n if isShorthand:\n # this is just the normal haxing for 'any' roles\n if env.config.add_function_parentheses and typ == 'any':\n addParen += 1\n # and now this stuff for operator()\n if (env.config.add_function_parentheses and typ == 'function' and\n title.endswith('operator()')):\n addParen += 1\n if ((typ == 'any' or typ == 'function') and\n title.endswith('operator') and\n displayName.endswith('operator()')):\n addParen += 1\n else:\n # our job here is to essentially nullify add_function_parentheses\n if env.config.add_function_parentheses:\n if typ == 'any' and displayName.endswith('()'):\n addParen += 1\n elif typ == 'function':\n if title.endswith('()') and not displayName.endswith('()'):\n title = title[:-2]\n else:\n if displayName.endswith('()'):\n addParen += 1\n if addParen > 0:\n title += '()' * addParen\n # and reconstruct the title again\n contnode += nodes.Text(title)\n return make_refnode(builder, fromdocname, docname,\n declaration.get_newest_id(), contnode, displayName\n ), declaration.objectType\n\n def resolve_xref(self, env: BuildEnvironment, fromdocname: str, builder: Builder,\n typ: str, target: str, node: pending_xref, contnode: Element\n ) -> Element:\n return self._resolve_xref_inner(env, fromdocname, builder, typ,\n target, node, contnode)[0]\n\n def resolve_any_xref(self, env: BuildEnvironment, fromdocname: str, builder: Builder,\n target: str, node: pending_xref, contnode: Element\n ) -> List[Tuple[str, Element]]:\n with logging.suppress_logging():\n retnode, objtype = self._resolve_xref_inner(env, fromdocname, builder,\n 'any', target, node, contnode)\n if retnode:\n if objtype == 'templateParam':\n return [('cpp:templateParam', retnode)]\n else:\n return [('cpp:' + self.role_for_objtype(objtype), retnode)]\n return []\n\n def get_objects(self) -> Iterator[Tuple[str, str, str, str, str, int]]:\n rootSymbol = self.data['root_symbol']\n for symbol in rootSymbol.get_all_symbols():\n if symbol.declaration is None:\n continue\n assert symbol.docname\n fullNestedName = symbol.get_full_nested_name()\n name = str(fullNestedName).lstrip(':')\n dispname = fullNestedName.get_display_string().lstrip(':')\n objectType = symbol.declaration.objectType\n docname = symbol.docname\n newestId = symbol.declaration.get_newest_id()\n yield (name, dispname, objectType, docname, newestId, 1)\n\n def get_full_qualified_name(self, node: Element) -> str:\n target = node.get('reftarget', None)\n if target is None:\n return None\n parentKey = node.get(\"cpp:parent_key\", None) # type: LookupKey\n if parentKey is None or len(parentKey.data) <= 0:\n return None\n\n rootSymbol = self.data['root_symbol']\n parentSymbol = rootSymbol.direct_lookup(parentKey)\n parentName = parentSymbol.get_full_nested_name()\n return '::'.join([str(parentName), target])\n\n\ndef setup(app: Sphinx) -> Dict[str, Any]:\n app.add_domain(CPPDomain)\n app.add_config_value(\"cpp_index_common_prefix\", [], 'env')\n app.add_config_value(\"cpp_id_attributes\", [], 'env')\n app.add_config_value(\"cpp_paren_attributes\", [], 'env')\n app.add_post_transform(AliasTransform)\n\n return {\n 'version': 'builtin',\n 'env_version': 2,\n 'parallel_read_safe': True,\n 'parallel_write_safe': True,\n }\n"}}},{"rowIdx":2074,"cells":{"function_name":{"kind":"string","value":"get"},"docstring":{"kind":"string","value":"Get an existing WebAppSitePushSettingsSlot resource's state with the given name, id, and optional extra\nproperties used to qualify the lookup.\n\n:param str resource_name: The unique name of the resulting resource.\n:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.\n:param pulumi.ResourceOptions opts: Options for the resource."},"masked_code":{"kind":"string","value":"# coding=utf-8\n# *** WARNING: this file was generated by the Pulumi SDK Generator. ***\n# *** Do not edit by hand unless you're certain you know what you are doing! ***\n\nimport warnings\nimport pulumi\nimport pulumi.runtime\nfrom typing import Any, Mapping, Optional, Sequence, Union\nfrom ... import _utilities, _tables\nfrom . import outputs\n\n__all__ = ['WebAppSitePushSettingsSlot']\n\n\nclass WebAppSitePushSettingsSlot(pulumi.CustomResource):\n def __init__(__self__,\n resource_name: str,\n opts: Optional[pulumi.ResourceOptions] = None,\n dynamic_tags_json: Optional[pulumi.Input[str]] = None,\n is_push_enabled: Optional[pulumi.Input[bool]] = None,\n kind: Optional[pulumi.Input[str]] = None,\n name: Optional[pulumi.Input[str]] = None,\n resource_group_name: Optional[pulumi.Input[str]] = None,\n slot: Optional[pulumi.Input[str]] = None,\n tag_whitelist_json: Optional[pulumi.Input[str]] = None,\n tags_requiring_auth: Optional[pulumi.Input[str]] = None,\n __props__=None,\n __name__=None,\n __opts__=None):\n \"\"\"\n Push settings for the App.\n\n :param str resource_name: The name of the resource.\n :param pulumi.ResourceOptions opts: Options for the resource.\n :param pulumi.Input[str] dynamic_tags_json: Gets or sets a JSON string containing a list of dynamic tags that will be evaluated from user claims in the push registration endpoint.\n :param pulumi.Input[bool] is_push_enabled: Gets or sets a flag indicating whether the Push endpoint is enabled.\n :param pulumi.Input[str] kind: Kind of resource.\n :param pulumi.Input[str] name: Name of web app.\n :param pulumi.Input[str] resource_group_name: Name of the resource group to which the resource belongs.\n :param pulumi.Input[str] slot: Name of web app slot. If not specified then will default to production slot.\n :param pulumi.Input[str] tag_whitelist_json: Gets or sets a JSON string containing a list of tags that are whitelisted for use by the push registration endpoint.\n :param pulumi.Input[str] tags_requiring_auth: Gets or sets a JSON string containing a list of tags that require user authentication to be used in the push registration endpoint.\n Tags can consist of alphanumeric characters and the following:\n '_', '@', '#', '.', ':', '-'. \n Validation should be performed at the PushRequestHandler.\n \"\"\"\n if __name__ is not None:\n warnings.warn(\"explicit use of __name__ is deprecated\", DeprecationWarning)\n resource_name = __name__\n if __opts__ is not None:\n warnings.warn(\"explicit use of __opts__ is deprecated, use 'opts' instead\", DeprecationWarning)\n opts = __opts__\n if opts is None:\n opts = pulumi.ResourceOptions()\n if not isinstance(opts, pulumi.ResourceOptions):\n raise TypeError('Expected resource options to be a ResourceOptions instance')\n if opts.version is None:\n opts.version = _utilities.get_version()\n if opts.id is None:\n if __props__ is not None:\n raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')\n __props__ = dict()\n\n __props__['dynamic_tags_json'] = dynamic_tags_json\n if is_push_enabled is None and not opts.urn:\n raise TypeError(\"Missing required property 'is_push_enabled'\")\n __props__['is_push_enabled'] = is_push_enabled\n __props__['kind'] = kind\n if name is None and not opts.urn:\n raise TypeError(\"Missing required property 'name'\")\n __props__['name'] = name\n if resource_group_name is None and not opts.urn:\n raise TypeError(\"Missing required property 'resource_group_name'\")\n __props__['resource_group_name'] = resource_group_name\n if slot is None and not opts.urn:\n raise TypeError(\"Missing required property 'slot'\")\n __props__['slot'] = slot\n __props__['tag_whitelist_json'] = tag_whitelist_json\n __props__['tags_requiring_auth'] = tags_requiring_auth\n __props__['system_data'] = None\n __props__['type'] = None\n alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_=\"azure-nextgen:web/v20200901:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/latest:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/latest:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20160801:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20160801:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20180201:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20180201:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20181101:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20181101:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20190801:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20190801:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20200601:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20200601:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20201001:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20201001:WebAppSitePushSettingsSlot\")])\n opts = pulumi.ResourceOptions.merge(opts, alias_opts)\n super(WebAppSitePushSettingsSlot, __self__).__init__(\n 'azure-native:web/v20200901:WebAppSitePushSettingsSlot',\n resource_name,\n __props__,\n opts)\n\n# MASKED: get function (lines 90-114)\n\n @property\n @pulumi.getter(name=\"dynamicTagsJson\")\n def dynamic_tags_json(self) -> pulumi.Output[Optional[str]]:\n \"\"\"\n Gets or sets a JSON string containing a list of dynamic tags that will be evaluated from user claims in the push registration endpoint.\n \"\"\"\n return pulumi.get(self, \"dynamic_tags_json\")\n\n @property\n @pulumi.getter(name=\"isPushEnabled\")\n def is_push_enabled(self) -> pulumi.Output[bool]:\n \"\"\"\n Gets or sets a flag indicating whether the Push endpoint is enabled.\n \"\"\"\n return pulumi.get(self, \"is_push_enabled\")\n\n @property\n @pulumi.getter\n def kind(self) -> pulumi.Output[Optional[str]]:\n \"\"\"\n Kind of resource.\n \"\"\"\n return pulumi.get(self, \"kind\")\n\n @property\n @pulumi.getter\n def name(self) -> pulumi.Output[str]:\n \"\"\"\n Resource Name.\n \"\"\"\n return pulumi.get(self, \"name\")\n\n @property\n @pulumi.getter(name=\"systemData\")\n def system_data(self) -> pulumi.Output['outputs.SystemDataResponse']:\n \"\"\"\n The system metadata relating to this resource.\n \"\"\"\n return pulumi.get(self, \"system_data\")\n\n @property\n @pulumi.getter(name=\"tagWhitelistJson\")\n def tag_whitelist_json(self) -> pulumi.Output[Optional[str]]:\n \"\"\"\n Gets or sets a JSON string containing a list of tags that are whitelisted for use by the push registration endpoint.\n \"\"\"\n return pulumi.get(self, \"tag_whitelist_json\")\n\n @property\n @pulumi.getter(name=\"tagsRequiringAuth\")\n def tags_requiring_auth(self) -> pulumi.Output[Optional[str]]:\n \"\"\"\n Gets or sets a JSON string containing a list of tags that require user authentication to be used in the push registration endpoint.\n Tags can consist of alphanumeric characters and the following:\n '_', '@', '#', '.', ':', '-'. \n Validation should be performed at the PushRequestHandler.\n \"\"\"\n return pulumi.get(self, \"tags_requiring_auth\")\n\n @property\n @pulumi.getter\n def type(self) -> pulumi.Output[str]:\n \"\"\"\n Resource type.\n \"\"\"\n return pulumi.get(self, \"type\")\n\n def translate_output_property(self, prop):\n return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop\n\n def translate_input_property(self, prop):\n return _tables.SNAKE_TO_CAMEL_CASE_TABLE.get(prop) or prop\n"},"implementation":{"kind":"string","value":" @staticmethod\n def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions] = None) -> 'WebAppSitePushSettingsSlot':\n \"\"\"\n Get an existing WebAppSitePushSettingsSlot resource's state with the given name, id, and optional extra\n properties used to qualify the lookup.\n\n :param str resource_name: The unique name of the resulting resource.\n :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.\n :param pulumi.ResourceOptions opts: Options for the resource.\n \"\"\"\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\n\n __props__ = dict()\n\n __props__[\"dynamic_tags_json\"] = None\n __props__[\"is_push_enabled\"] = None\n __props__[\"kind\"] = None\n __props__[\"name\"] = None\n __props__[\"system_data\"] = None\n __props__[\"tag_whitelist_json\"] = None\n __props__[\"tags_requiring_auth\"] = None\n __props__[\"type\"] = None\n return WebAppSitePushSettingsSlot(resource_name, opts=opts, __props__=__props__)"},"start_line":{"kind":"number","value":90,"string":"90"},"end_line":{"kind":"number","value":114,"string":"114"},"file_content":{"kind":"string","value":"# coding=utf-8\n# *** WARNING: this file was generated by the Pulumi SDK Generator. ***\n# *** Do not edit by hand unless you're certain you know what you are doing! ***\n\nimport warnings\nimport pulumi\nimport pulumi.runtime\nfrom typing import Any, Mapping, Optional, Sequence, Union\nfrom ... import _utilities, _tables\nfrom . import outputs\n\n__all__ = ['WebAppSitePushSettingsSlot']\n\n\nclass WebAppSitePushSettingsSlot(pulumi.CustomResource):\n def __init__(__self__,\n resource_name: str,\n opts: Optional[pulumi.ResourceOptions] = None,\n dynamic_tags_json: Optional[pulumi.Input[str]] = None,\n is_push_enabled: Optional[pulumi.Input[bool]] = None,\n kind: Optional[pulumi.Input[str]] = None,\n name: Optional[pulumi.Input[str]] = None,\n resource_group_name: Optional[pulumi.Input[str]] = None,\n slot: Optional[pulumi.Input[str]] = None,\n tag_whitelist_json: Optional[pulumi.Input[str]] = None,\n tags_requiring_auth: Optional[pulumi.Input[str]] = None,\n __props__=None,\n __name__=None,\n __opts__=None):\n \"\"\"\n Push settings for the App.\n\n :param str resource_name: The name of the resource.\n :param pulumi.ResourceOptions opts: Options for the resource.\n :param pulumi.Input[str] dynamic_tags_json: Gets or sets a JSON string containing a list of dynamic tags that will be evaluated from user claims in the push registration endpoint.\n :param pulumi.Input[bool] is_push_enabled: Gets or sets a flag indicating whether the Push endpoint is enabled.\n :param pulumi.Input[str] kind: Kind of resource.\n :param pulumi.Input[str] name: Name of web app.\n :param pulumi.Input[str] resource_group_name: Name of the resource group to which the resource belongs.\n :param pulumi.Input[str] slot: Name of web app slot. If not specified then will default to production slot.\n :param pulumi.Input[str] tag_whitelist_json: Gets or sets a JSON string containing a list of tags that are whitelisted for use by the push registration endpoint.\n :param pulumi.Input[str] tags_requiring_auth: Gets or sets a JSON string containing a list of tags that require user authentication to be used in the push registration endpoint.\n Tags can consist of alphanumeric characters and the following:\n '_', '@', '#', '.', ':', '-'. \n Validation should be performed at the PushRequestHandler.\n \"\"\"\n if __name__ is not None:\n warnings.warn(\"explicit use of __name__ is deprecated\", DeprecationWarning)\n resource_name = __name__\n if __opts__ is not None:\n warnings.warn(\"explicit use of __opts__ is deprecated, use 'opts' instead\", DeprecationWarning)\n opts = __opts__\n if opts is None:\n opts = pulumi.ResourceOptions()\n if not isinstance(opts, pulumi.ResourceOptions):\n raise TypeError('Expected resource options to be a ResourceOptions instance')\n if opts.version is None:\n opts.version = _utilities.get_version()\n if opts.id is None:\n if __props__ is not None:\n raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')\n __props__ = dict()\n\n __props__['dynamic_tags_json'] = dynamic_tags_json\n if is_push_enabled is None and not opts.urn:\n raise TypeError(\"Missing required property 'is_push_enabled'\")\n __props__['is_push_enabled'] = is_push_enabled\n __props__['kind'] = kind\n if name is None and not opts.urn:\n raise TypeError(\"Missing required property 'name'\")\n __props__['name'] = name\n if resource_group_name is None and not opts.urn:\n raise TypeError(\"Missing required property 'resource_group_name'\")\n __props__['resource_group_name'] = resource_group_name\n if slot is None and not opts.urn:\n raise TypeError(\"Missing required property 'slot'\")\n __props__['slot'] = slot\n __props__['tag_whitelist_json'] = tag_whitelist_json\n __props__['tags_requiring_auth'] = tags_requiring_auth\n __props__['system_data'] = None\n __props__['type'] = None\n alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_=\"azure-nextgen:web/v20200901:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/latest:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/latest:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20160801:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20160801:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20180201:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20180201:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20181101:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20181101:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20190801:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20190801:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20200601:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20200601:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-native:web/v20201001:WebAppSitePushSettingsSlot\"), pulumi.Alias(type_=\"azure-nextgen:web/v20201001:WebAppSitePushSettingsSlot\")])\n opts = pulumi.ResourceOptions.merge(opts, alias_opts)\n super(WebAppSitePushSettingsSlot, __self__).__init__(\n 'azure-native:web/v20200901:WebAppSitePushSettingsSlot',\n resource_name,\n __props__,\n opts)\n\n @staticmethod\n def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions] = None) -> 'WebAppSitePushSettingsSlot':\n \"\"\"\n Get an existing WebAppSitePushSettingsSlot resource's state with the given name, id, and optional extra\n properties used to qualify the lookup.\n\n :param str resource_name: The unique name of the resulting resource.\n :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.\n :param pulumi.ResourceOptions opts: Options for the resource.\n \"\"\"\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\n\n __props__ = dict()\n\n __props__[\"dynamic_tags_json\"] = None\n __props__[\"is_push_enabled\"] = None\n __props__[\"kind\"] = None\n __props__[\"name\"] = None\n __props__[\"system_data\"] = None\n __props__[\"tag_whitelist_json\"] = None\n __props__[\"tags_requiring_auth\"] = None\n __props__[\"type\"] = None\n return WebAppSitePushSettingsSlot(resource_name, opts=opts, __props__=__props__)\n\n @property\n @pulumi.getter(name=\"dynamicTagsJson\")\n def dynamic_tags_json(self) -> pulumi.Output[Optional[str]]:\n \"\"\"\n Gets or sets a JSON string containing a list of dynamic tags that will be evaluated from user claims in the push registration endpoint.\n \"\"\"\n return pulumi.get(self, \"dynamic_tags_json\")\n\n @property\n @pulumi.getter(name=\"isPushEnabled\")\n def is_push_enabled(self) -> pulumi.Output[bool]:\n \"\"\"\n Gets or sets a flag indicating whether the Push endpoint is enabled.\n \"\"\"\n return pulumi.get(self, \"is_push_enabled\")\n\n @property\n @pulumi.getter\n def kind(self) -> pulumi.Output[Optional[str]]:\n \"\"\"\n Kind of resource.\n \"\"\"\n return pulumi.get(self, \"kind\")\n\n @property\n @pulumi.getter\n def name(self) -> pulumi.Output[str]:\n \"\"\"\n Resource Name.\n \"\"\"\n return pulumi.get(self, \"name\")\n\n @property\n @pulumi.getter(name=\"systemData\")\n def system_data(self) -> pulumi.Output['outputs.SystemDataResponse']:\n \"\"\"\n The system metadata relating to this resource.\n \"\"\"\n return pulumi.get(self, \"system_data\")\n\n @property\n @pulumi.getter(name=\"tagWhitelistJson\")\n def tag_whitelist_json(self) -> pulumi.Output[Optional[str]]:\n \"\"\"\n Gets or sets a JSON string containing a list of tags that are whitelisted for use by the push registration endpoint.\n \"\"\"\n return pulumi.get(self, \"tag_whitelist_json\")\n\n @property\n @pulumi.getter(name=\"tagsRequiringAuth\")\n def tags_requiring_auth(self) -> pulumi.Output[Optional[str]]:\n \"\"\"\n Gets or sets a JSON string containing a list of tags that require user authentication to be used in the push registration endpoint.\n Tags can consist of alphanumeric characters and the following:\n '_', '@', '#', '.', ':', '-'. \n Validation should be performed at the PushRequestHandler.\n \"\"\"\n return pulumi.get(self, \"tags_requiring_auth\")\n\n @property\n @pulumi.getter\n def type(self) -> pulumi.Output[str]:\n \"\"\"\n Resource type.\n \"\"\"\n return pulumi.get(self, \"type\")\n\n def translate_output_property(self, prop):\n return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop\n\n def translate_input_property(self, prop):\n return _tables.SNAKE_TO_CAMEL_CASE_TABLE.get(prop) or prop\n\n"}}},{"rowIdx":2075,"cells":{"function_name":{"kind":"string","value":"on_help"},"docstring":{"kind":"string","value":" Bring up the Kiessig fringe calculator Documentation whenever\n the HELP button is clicked.\n Calls DocumentationWindow with the path of the location within the\n documentation tree (after /doc/ ....\". Note that when using old\n versions of Wx (before 2.9) and thus not the release version of\n installers, the help comes up at the top level of the file as\n webbrowser does not pass anything past the # to the browser when it is\n running \"file:///....\"\n\n:param evt: Triggers on clicking the help button"},"masked_code":{"kind":"string","value":"\"\"\"\nThis software was developed by the University of Tennessee as part of the\nDistributed Data Analysis of Neutron Scattering Experiments (DANSE)\nproject funded by the US National Science Foundation.\n\nSee the license text in license.txt\n\ncopyright 2008, 2009, University of Tennessee\n\"\"\"\n\nimport wx\nimport sys\n\nfrom sas.sasgui.guiframe.panel_base import PanelBase\nfrom sas.sascalc.calculator.kiessig_calculator import KiessigThicknessCalculator\nfrom calculator_widgets import OutputTextCtrl\nfrom calculator_widgets import InputTextCtrl\nfrom sas.sasgui.perspectives.calculator import calculator_widgets as widget\nfrom sas.sasgui.guiframe.documentation_window import DocumentationWindow\n\n_BOX_WIDTH = 77\n#Slit length panel size\nif sys.platform.count(\"win32\") > 0:\n PANEL_TOP = 0\n PANEL_WIDTH = 500\n PANEL_HEIGHT = 230\n FONT_VARIANT = 0\nelse:\n PANEL_TOP = 60\n PANEL_WIDTH = 560\n PANEL_HEIGHT = 230\n FONT_VARIANT = 1\n \nclass KiessigThicknessCalculatorPanel(wx.Panel, PanelBase):\n \"\"\"\n Provides the Kiessig thickness calculator GUI.\n \"\"\"\n ## Internal nickname for the window, used by the AUI manager\n window_name = \"Kiessig Thickness Calculator\"\n ## Name to appear on the window title bar\n window_caption = \"Kiessig Thickness Calculator\"\n ## Flag to tell the AUI manager to put this panel in the center pane\n CENTER_PANE = True\n\n def __init__(self, parent, *args, **kwds):\n wx.Panel.__init__(self, parent, *args, **kwds)\n PanelBase.__init__(self)\n #Font size\n self.SetWindowVariant(variant=FONT_VARIANT)\n # Object that receive status event\n self.parent = parent\n self.kiessig = KiessigThicknessCalculator()\n #layout attribute\n self.hint_sizer = None\n self._do_layout()\n\n def _define_structure(self):\n \"\"\"\n Define the main sizers building to build this application.\n \"\"\"\n self.main_sizer = wx.BoxSizer(wx.VERTICAL)\n self.box_source = wx.StaticBox(self, -1,\n str(\"Kiessig Thickness Calculator\"))\n self.boxsizer_source = wx.StaticBoxSizer(self.box_source,\n wx.VERTICAL)\n self.dq_name_sizer = wx.BoxSizer(wx.HORIZONTAL)\n self.thickness_size_sizer = wx.BoxSizer(wx.HORIZONTAL)\n self.hint_sizer = wx.BoxSizer(wx.HORIZONTAL)\n self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)\n\n def _layout_dq_name(self):\n \"\"\"\n Fill the sizer containing dq name\n \"\"\"\n # get the default dq\n dq_value = str(self.kiessig.get_deltaq())\n dq_unit_txt = wx.StaticText(self, -1, '[1/A]')\n dq_name_txt = wx.StaticText(self, -1,\n 'Kiessig Fringe Width (Delta Q): ')\n self.dq_name_tcl = InputTextCtrl(self, -1, \n size=(_BOX_WIDTH,-1))\n dq_hint = \"Type the Kiessig Fringe Width (Delta Q)\"\n self.dq_name_tcl.SetValue(dq_value)\n self.dq_name_tcl.SetToolTipString(dq_hint)\n #control that triggers importing data\n id = wx.NewId()\n self.compute_button = wx.Button(self, id, \"Compute\")\n hint_on_compute = \"Compute the diameter/thickness in the real space.\"\n self.compute_button.SetToolTipString(hint_on_compute)\n self.Bind(wx.EVT_BUTTON, self.on_compute, id=id)\n self.dq_name_sizer.AddMany([(dq_name_txt, 0, wx.LEFT, 15),\n (self.dq_name_tcl, 0, wx.LEFT, 15),\n (dq_unit_txt, 0, wx.LEFT, 10),\n (self.compute_button, 0, wx.LEFT, 30)])\n\n def _layout_thickness_size(self):\n \"\"\"\n Fill the sizer containing thickness information\n \"\"\"\n thick_unit = '['+self.kiessig.get_thickness_unit() +']'\n thickness_size_txt = wx.StaticText(self, -1,\n 'Thickness (or Diameter): ')\n self.thickness_size_tcl = OutputTextCtrl(self, -1,\n size=(_BOX_WIDTH,-1))\n thickness_size_hint = \" Estimated Size in Real Space\"\n self.thickness_size_tcl.SetToolTipString(thickness_size_hint)\n thickness_size_unit_txt = wx.StaticText(self, -1, thick_unit)\n\n self.thickness_size_sizer.AddMany([(thickness_size_txt, 0, wx.LEFT, 15),\n (self.thickness_size_tcl, 0, wx.LEFT, 15),\n (thickness_size_unit_txt, 0, wx.LEFT, 10)])\n\n def _layout_hint(self):\n \"\"\"\n Fill the sizer containing hint \n \"\"\"\n hint_msg = \"This tool is to approximately estimate \"\n hint_msg += \"the thickness of a layer\"\n hint_msg += \" or the diameter of particles\\n \"\n hint_msg += \"from the Kiessig fringe width in SAS/NR data.\"\n hint_msg += \"\"\n self.hint_txt = wx.StaticText(self, -1, hint_msg)\n self.hint_sizer.AddMany([(self.hint_txt, 0, wx.LEFT, 15)])\n\n def _layout_button(self): \n \"\"\"\n Do the layout for the button widgets\n \"\"\" \n id = wx.NewId()\n self.bt_help = wx.Button(self, id, 'HELP')\n self.bt_help.Bind(wx.EVT_BUTTON, self.on_help)\n self.bt_help.SetToolTipString(\"Help using the Kiessig fringe calculator.\")\n\n self.bt_close = wx.Button(self, wx.ID_CANCEL, 'Close')\n self.bt_close.Bind(wx.EVT_BUTTON, self.on_close)\n self.bt_close.SetToolTipString(\"Close this window.\")\n self.button_sizer.AddMany([(self.bt_help, 0, wx.LEFT, 260),\n (self.bt_close, 0, wx.LEFT, 20)])\n\n def _do_layout(self):\n \"\"\"\n Draw window content\n \"\"\"\n self._define_structure()\n self._layout_dq_name()\n self._layout_thickness_size()\n self._layout_hint()\n self._layout_button()\n self.boxsizer_source.AddMany([(self.dq_name_sizer, 0,\n wx.EXPAND|wx.TOP|wx.BOTTOM, 5),\n (self.thickness_size_sizer, 0,\n wx.EXPAND|wx.TOP|wx.BOTTOM, 5),\n (self.hint_sizer, 0,\n wx.EXPAND|wx.TOP|wx.BOTTOM, 5)])\n self.main_sizer.AddMany([(self.boxsizer_source, 0, wx.ALL, 10),\n (self.button_sizer, 0,\n wx.EXPAND|wx.TOP|wx.BOTTOM, 5)])\n self.SetSizer(self.main_sizer)\n self.SetAutoLayout(True)\n\n# MASKED: on_help function (lines 161-177)\n\n def on_close(self, event):\n \"\"\"\n close the window containing this panel\n \"\"\"\n self.parent.Close()\n if event is not None:\n event.Skip()\n\n def on_compute(self, event):\n \"\"\"\n Execute the computation of thickness\n \"\"\"\n # skip for another event\n if event is not None:\n event.Skip()\n dq = self.dq_name_tcl.GetValue()\n self.kiessig.set_deltaq(dq)\n # calculate the thickness \n output = self.kiessig.compute_thickness()\n thickness = self.format_number(output)\n # set tcl\n self.thickness_size_tcl.SetValue(str(thickness))\n\n def format_number(self, value=None):\n \"\"\"\n Return a float in a standardized, human-readable formatted string\n \"\"\"\n try:\n value = float(value)\n except:\n output = None\n return output\n\n output = \"%-7.4g\" % value\n return output.lstrip().rstrip()\n \n def _onparamEnter(self, event = None):\n \"\"\"\n On Text_enter_callback, perform compute\n \"\"\"\n self.on_compute(event)\n\nclass KiessigWindow(widget.CHILD_FRAME):\n def __init__(self, parent=None, manager=None, \n title=\"Kiessig Thickness Calculator\",\n size=(PANEL_WIDTH,PANEL_HEIGHT), *args, **kwds):\n kwds['title'] = title\n kwds['size'] = size\n widget.CHILD_FRAME.__init__(self, parent, *args, **kwds)\n self.parent = parent\n self.manager = manager\n self.panel = KiessigThicknessCalculatorPanel(parent=self)\n self.Bind(wx.EVT_CLOSE, self.on_close)\n self.SetPosition((wx.LEFT, PANEL_TOP))\n self.Show(True)\n \n def on_close(self, event):\n \"\"\"\n Close event\n \"\"\"\n if self.manager is not None:\n self.manager.kiessig_frame = None\n self.Destroy()\n\nif __name__ == \"__main__\":\n app = wx.PySimpleApp()\n widget.CHILD_FRAME = wx.Frame\n frame = KiessigWindow()\n frame.Show(True)\n app.MainLoop()"},"implementation":{"kind":"string","value":" def on_help(self, event):\n \"\"\"\n Bring up the Kiessig fringe calculator Documentation whenever\n the HELP button is clicked.\n Calls DocumentationWindow with the path of the location within the\n documentation tree (after /doc/ ....\". Note that when using old\n versions of Wx (before 2.9) and thus not the release version of\n installers, the help comes up at the top level of the file as\n webbrowser does not pass anything past the # to the browser when it is\n running \"file:///....\"\n\n :param evt: Triggers on clicking the help button\n \"\"\"\n _TreeLocation = \"user/sasgui/perspectives/calculator/\"\n _TreeLocation += \"kiessig_calculator_help.html\"\n _doc_viewer = DocumentationWindow(self, -1, _TreeLocation, \"\",\n \"Density/Volume Calculator Help\")"},"start_line":{"kind":"number","value":161,"string":"161"},"end_line":{"kind":"number","value":177,"string":"177"},"file_content":{"kind":"string","value":"\"\"\"\nThis software was developed by the University of Tennessee as part of the\nDistributed Data Analysis of Neutron Scattering Experiments (DANSE)\nproject funded by the US National Science Foundation.\n\nSee the license text in license.txt\n\ncopyright 2008, 2009, University of Tennessee\n\"\"\"\n\nimport wx\nimport sys\n\nfrom sas.sasgui.guiframe.panel_base import PanelBase\nfrom sas.sascalc.calculator.kiessig_calculator import KiessigThicknessCalculator\nfrom calculator_widgets import OutputTextCtrl\nfrom calculator_widgets import InputTextCtrl\nfrom sas.sasgui.perspectives.calculator import calculator_widgets as widget\nfrom sas.sasgui.guiframe.documentation_window import DocumentationWindow\n\n_BOX_WIDTH = 77\n#Slit length panel size\nif sys.platform.count(\"win32\") > 0:\n PANEL_TOP = 0\n PANEL_WIDTH = 500\n PANEL_HEIGHT = 230\n FONT_VARIANT = 0\nelse:\n PANEL_TOP = 60\n PANEL_WIDTH = 560\n PANEL_HEIGHT = 230\n FONT_VARIANT = 1\n \nclass KiessigThicknessCalculatorPanel(wx.Panel, PanelBase):\n \"\"\"\n Provides the Kiessig thickness calculator GUI.\n \"\"\"\n ## Internal nickname for the window, used by the AUI manager\n window_name = \"Kiessig Thickness Calculator\"\n ## Name to appear on the window title bar\n window_caption = \"Kiessig Thickness Calculator\"\n ## Flag to tell the AUI manager to put this panel in the center pane\n CENTER_PANE = True\n\n def __init__(self, parent, *args, **kwds):\n wx.Panel.__init__(self, parent, *args, **kwds)\n PanelBase.__init__(self)\n #Font size\n self.SetWindowVariant(variant=FONT_VARIANT)\n # Object that receive status event\n self.parent = parent\n self.kiessig = KiessigThicknessCalculator()\n #layout attribute\n self.hint_sizer = None\n self._do_layout()\n\n def _define_structure(self):\n \"\"\"\n Define the main sizers building to build this application.\n \"\"\"\n self.main_sizer = wx.BoxSizer(wx.VERTICAL)\n self.box_source = wx.StaticBox(self, -1,\n str(\"Kiessig Thickness Calculator\"))\n self.boxsizer_source = wx.StaticBoxSizer(self.box_source,\n wx.VERTICAL)\n self.dq_name_sizer = wx.BoxSizer(wx.HORIZONTAL)\n self.thickness_size_sizer = wx.BoxSizer(wx.HORIZONTAL)\n self.hint_sizer = wx.BoxSizer(wx.HORIZONTAL)\n self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)\n\n def _layout_dq_name(self):\n \"\"\"\n Fill the sizer containing dq name\n \"\"\"\n # get the default dq\n dq_value = str(self.kiessig.get_deltaq())\n dq_unit_txt = wx.StaticText(self, -1, '[1/A]')\n dq_name_txt = wx.StaticText(self, -1,\n 'Kiessig Fringe Width (Delta Q): ')\n self.dq_name_tcl = InputTextCtrl(self, -1, \n size=(_BOX_WIDTH,-1))\n dq_hint = \"Type the Kiessig Fringe Width (Delta Q)\"\n self.dq_name_tcl.SetValue(dq_value)\n self.dq_name_tcl.SetToolTipString(dq_hint)\n #control that triggers importing data\n id = wx.NewId()\n self.compute_button = wx.Button(self, id, \"Compute\")\n hint_on_compute = \"Compute the diameter/thickness in the real space.\"\n self.compute_button.SetToolTipString(hint_on_compute)\n self.Bind(wx.EVT_BUTTON, self.on_compute, id=id)\n self.dq_name_sizer.AddMany([(dq_name_txt, 0, wx.LEFT, 15),\n (self.dq_name_tcl, 0, wx.LEFT, 15),\n (dq_unit_txt, 0, wx.LEFT, 10),\n (self.compute_button, 0, wx.LEFT, 30)])\n\n def _layout_thickness_size(self):\n \"\"\"\n Fill the sizer containing thickness information\n \"\"\"\n thick_unit = '['+self.kiessig.get_thickness_unit() +']'\n thickness_size_txt = wx.StaticText(self, -1,\n 'Thickness (or Diameter): ')\n self.thickness_size_tcl = OutputTextCtrl(self, -1,\n size=(_BOX_WIDTH,-1))\n thickness_size_hint = \" Estimated Size in Real Space\"\n self.thickness_size_tcl.SetToolTipString(thickness_size_hint)\n thickness_size_unit_txt = wx.StaticText(self, -1, thick_unit)\n\n self.thickness_size_sizer.AddMany([(thickness_size_txt, 0, wx.LEFT, 15),\n (self.thickness_size_tcl, 0, wx.LEFT, 15),\n (thickness_size_unit_txt, 0, wx.LEFT, 10)])\n\n def _layout_hint(self):\n \"\"\"\n Fill the sizer containing hint \n \"\"\"\n hint_msg = \"This tool is to approximately estimate \"\n hint_msg += \"the thickness of a layer\"\n hint_msg += \" or the diameter of particles\\n \"\n hint_msg += \"from the Kiessig fringe width in SAS/NR data.\"\n hint_msg += \"\"\n self.hint_txt = wx.StaticText(self, -1, hint_msg)\n self.hint_sizer.AddMany([(self.hint_txt, 0, wx.LEFT, 15)])\n\n def _layout_button(self): \n \"\"\"\n Do the layout for the button widgets\n \"\"\" \n id = wx.NewId()\n self.bt_help = wx.Button(self, id, 'HELP')\n self.bt_help.Bind(wx.EVT_BUTTON, self.on_help)\n self.bt_help.SetToolTipString(\"Help using the Kiessig fringe calculator.\")\n\n self.bt_close = wx.Button(self, wx.ID_CANCEL, 'Close')\n self.bt_close.Bind(wx.EVT_BUTTON, self.on_close)\n self.bt_close.SetToolTipString(\"Close this window.\")\n self.button_sizer.AddMany([(self.bt_help, 0, wx.LEFT, 260),\n (self.bt_close, 0, wx.LEFT, 20)])\n\n def _do_layout(self):\n \"\"\"\n Draw window content\n \"\"\"\n self._define_structure()\n self._layout_dq_name()\n self._layout_thickness_size()\n self._layout_hint()\n self._layout_button()\n self.boxsizer_source.AddMany([(self.dq_name_sizer, 0,\n wx.EXPAND|wx.TOP|wx.BOTTOM, 5),\n (self.thickness_size_sizer, 0,\n wx.EXPAND|wx.TOP|wx.BOTTOM, 5),\n (self.hint_sizer, 0,\n wx.EXPAND|wx.TOP|wx.BOTTOM, 5)])\n self.main_sizer.AddMany([(self.boxsizer_source, 0, wx.ALL, 10),\n (self.button_sizer, 0,\n wx.EXPAND|wx.TOP|wx.BOTTOM, 5)])\n self.SetSizer(self.main_sizer)\n self.SetAutoLayout(True)\n\n def on_help(self, event):\n \"\"\"\n Bring up the Kiessig fringe calculator Documentation whenever\n the HELP button is clicked.\n Calls DocumentationWindow with the path of the location within the\n documentation tree (after /doc/ ....\". Note that when using old\n versions of Wx (before 2.9) and thus not the release version of\n installers, the help comes up at the top level of the file as\n webbrowser does not pass anything past the # to the browser when it is\n running \"file:///....\"\n\n :param evt: Triggers on clicking the help button\n \"\"\"\n _TreeLocation = \"user/sasgui/perspectives/calculator/\"\n _TreeLocation += \"kiessig_calculator_help.html\"\n _doc_viewer = DocumentationWindow(self, -1, _TreeLocation, \"\",\n \"Density/Volume Calculator Help\")\n\n def on_close(self, event):\n \"\"\"\n close the window containing this panel\n \"\"\"\n self.parent.Close()\n if event is not None:\n event.Skip()\n\n def on_compute(self, event):\n \"\"\"\n Execute the computation of thickness\n \"\"\"\n # skip for another event\n if event is not None:\n event.Skip()\n dq = self.dq_name_tcl.GetValue()\n self.kiessig.set_deltaq(dq)\n # calculate the thickness \n output = self.kiessig.compute_thickness()\n thickness = self.format_number(output)\n # set tcl\n self.thickness_size_tcl.SetValue(str(thickness))\n\n def format_number(self, value=None):\n \"\"\"\n Return a float in a standardized, human-readable formatted string\n \"\"\"\n try:\n value = float(value)\n except:\n output = None\n return output\n\n output = \"%-7.4g\" % value\n return output.lstrip().rstrip()\n \n def _onparamEnter(self, event = None):\n \"\"\"\n On Text_enter_callback, perform compute\n \"\"\"\n self.on_compute(event)\n\nclass KiessigWindow(widget.CHILD_FRAME):\n def __init__(self, parent=None, manager=None, \n title=\"Kiessig Thickness Calculator\",\n size=(PANEL_WIDTH,PANEL_HEIGHT), *args, **kwds):\n kwds['title'] = title\n kwds['size'] = size\n widget.CHILD_FRAME.__init__(self, parent, *args, **kwds)\n self.parent = parent\n self.manager = manager\n self.panel = KiessigThicknessCalculatorPanel(parent=self)\n self.Bind(wx.EVT_CLOSE, self.on_close)\n self.SetPosition((wx.LEFT, PANEL_TOP))\n self.Show(True)\n \n def on_close(self, event):\n \"\"\"\n Close event\n \"\"\"\n if self.manager is not None:\n self.manager.kiessig_frame = None\n self.Destroy()\n\nif __name__ == \"__main__\":\n app = wx.PySimpleApp()\n widget.CHILD_FRAME = wx.Frame\n frame = KiessigWindow()\n frame.Show(True)\n app.MainLoop()\n"}}},{"rowIdx":2076,"cells":{"function_name":{"kind":"string","value":"blend"},"docstring":{"kind":"string","value":"Blend image1 and image2 using 'factor'.\n\nFactor can be above 0.0. A value of 0.0 means only image1 is used.\nA value of 1.0 means only image2 is used. A value between 0.0 and\n1.0 means we linearly interpolate the pixel values between the two\nimages. A value greater than 1.0 \"extrapolates\" the difference\nbetween the two pixel values, and we clip the results to values\nbetween 0 and 255.\n\nArgs:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\nReturns:\n A blended image Tensor of type uint8."},"masked_code":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\n# MASKED: blend function (lines 150-190)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)"},"implementation":{"kind":"string","value":"def blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)"},"start_line":{"kind":"number","value":150,"string":"150"},"end_line":{"kind":"number","value":190,"string":"190"},"file_content":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)\n"}}},{"rowIdx":2077,"cells":{"function_name":{"kind":"string","value":"rotate"},"docstring":{"kind":"string","value":"Rotates the image by degrees either clockwise or counterclockwise.\n\nArgs:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\nReturns:\n The rotated version of image."},"masked_code":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\n# MASKED: rotate function (lines 295-317)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)"},"implementation":{"kind":"string","value":"def rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)"},"start_line":{"kind":"number","value":295,"string":"295"},"end_line":{"kind":"number","value":317,"string":"317"},"file_content":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)\n"}}},{"rowIdx":2078,"cells":{"function_name":{"kind":"string","value":"_clip_bbox"},"docstring":{"kind":"string","value":"Clip bounding box coordinates between 0 and 1.\n\nArgs:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\nReturns:\n Clipped coordinate values between 0 and 1."},"masked_code":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\n# MASKED: _clip_bbox function (lines 435-451)\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)"},"implementation":{"kind":"string","value":"def _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x"},"start_line":{"kind":"number","value":435,"string":"435"},"end_line":{"kind":"number","value":451,"string":"451"},"file_content":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)\n"}}},{"rowIdx":2079,"cells":{"function_name":{"kind":"string","value":"_rotate_bbox"},"docstring":{"kind":"string","value":"Rotates the bbox coordinated by degrees.\n\nArgs:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\nReturns:\n A tensor of the same shape as bbox, but now with the rotated coordinates."},"masked_code":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\n# MASKED: _rotate_bbox function (lines 785-835)\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)"},"implementation":{"kind":"string","value":"def _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])"},"start_line":{"kind":"number","value":785,"string":"785"},"end_line":{"kind":"number","value":835,"string":"835"},"file_content":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)\n"}}},{"rowIdx":2080,"cells":{"function_name":{"kind":"string","value":"_shift_bbox"},"docstring":{"kind":"string","value":"Shifts the bbox coordinates by pixels.\n\nArgs:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\nReturns:\n A tensor of the same shape as bbox, but now with the shifted coordinates."},"masked_code":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\n# MASKED: _shift_bbox function (lines 881-919)\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)"},"implementation":{"kind":"string","value":"def _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])"},"start_line":{"kind":"number","value":881,"string":"881"},"end_line":{"kind":"number","value":919,"string":"919"},"file_content":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)\n"}}},{"rowIdx":2081,"cells":{"function_name":{"kind":"string","value":"_shear_bbox"},"docstring":{"kind":"string","value":"Shifts the bbox according to how the image was sheared.\n\nArgs:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\nReturns:\n A tensor of the same shape as bbox, but now with the shifted coordinates."},"masked_code":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\n# MASKED: _shear_bbox function (lines 978-1025)\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)"},"implementation":{"kind":"string","value":"def _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])"},"start_line":{"kind":"number","value":978,"string":"978"},"end_line":{"kind":"number","value":1025,"string":"1,025"},"file_content":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)\n"}}},{"rowIdx":2082,"cells":{"function_name":{"kind":"string","value":"distort_image_with_autoaugment"},"docstring":{"kind":"string","value":"Applies the AutoAugment policy to `image` and `bboxes`.\n\nArgs:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\nReturns:\n A tuple containing the augmented versions of `image` and `bboxes`."},"masked_code":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n# MASKED: distort_image_with_autoaugment function (lines 1591-1629)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)"},"implementation":{"kind":"string","value":"@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)"},"start_line":{"kind":"number","value":1591,"string":"1,591"},"end_line":{"kind":"number","value":1629,"string":"1,629"},"file_content":{"kind":"string","value":"# Copyright 2020 Google Research. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"AutoAugment.\n\n[1] Barret, et al. Learning Data Augmentation Strategies for Object Detection.\n Arxiv: https://arxiv.org/abs/1906.11172\n\"\"\"\nimport inspect\nimport math\nfrom absl import logging\nimport tensorflow.compat.v1 as tf\nfrom tensorflow_addons import image as image_ops\n\nimport hparams_config\n\n# This signifies the max integer that the controller RNN could predict for the\n# augmentation scheme.\n_MAX_LEVEL = 10.\n\n# Represents an invalid bounding box that is used for checking for padding\n# lists of bounding box coordinates for a few augmentation operations\n_INVALID_BOX = [[-1.0, -1.0, -1.0, -1.0]]\n\n\ndef policy_v0():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n ]\n return policy\n\n\ndef policy_v1():\n \"\"\"Autoaugment policy that was used in AutoAugment Detection Paper.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 0.6, 4), ('Equalize', 0.8, 10)],\n [('TranslateY_Only_BBoxes', 0.2, 2), ('Cutout', 0.8, 8)],\n [('Sharpness', 0.0, 8), ('ShearX_BBox', 0.4, 0)],\n [('ShearY_BBox', 1.0, 2), ('TranslateY_Only_BBoxes', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('Color', 1.0, 6)],\n [('Color', 0.0, 0), ('ShearX_Only_BBoxes', 0.8, 4)],\n [('ShearY_Only_BBoxes', 0.8, 2), ('Flip_Only_BBoxes', 0.0, 10)],\n [('Equalize', 0.6, 10), ('TranslateX_BBox', 0.2, 2)],\n [('Color', 1.0, 10), ('TranslateY_Only_BBoxes', 0.4, 6)],\n [('Rotate_BBox', 0.8, 10), ('Contrast', 0.0, 10)],\n [('Cutout', 0.2, 2), ('Brightness', 0.8, 10)],\n [('Color', 1.0, 6), ('Equalize', 1.0, 2)],\n [('Cutout_Only_BBoxes', 0.4, 6), ('TranslateY_Only_BBoxes', 0.8, 2)],\n [('Color', 0.2, 8), ('Rotate_BBox', 0.8, 10)],\n [('Sharpness', 0.4, 4), ('TranslateY_Only_BBoxes', 0.0, 4)],\n [('Sharpness', 1.0, 4), ('SolarizeAdd', 0.4, 4)],\n [('Rotate_BBox', 1.0, 8), ('Sharpness', 0.2, 8)],\n [('ShearY_BBox', 0.6, 10), ('Equalize_Only_BBoxes', 0.6, 8)],\n [('ShearX_BBox', 0.2, 6), ('TranslateY_Only_BBoxes', 0.2, 10)],\n [('SolarizeAdd', 0.6, 8), ('Brightness', 0.8, 10)],\n ]\n return policy\n\n\ndef policy_vtest():\n \"\"\"Autoaugment test policy for debugging.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('TranslateX_BBox', 1.0, 4), ('Equalize', 1.0, 10)],\n ]\n return policy\n\n\ndef policy_v2():\n \"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Color', 0.0, 6), ('Cutout', 0.6, 8), ('Sharpness', 0.4, 8)],\n [('Rotate_BBox', 0.4, 8), ('Sharpness', 0.4, 2),\n ('Rotate_BBox', 0.8, 10)],\n [('TranslateY_BBox', 1.0, 8), ('AutoContrast', 0.8, 2)],\n [('AutoContrast', 0.4, 6), ('ShearX_BBox', 0.8, 8),\n ('Brightness', 0.0, 10)],\n [('SolarizeAdd', 0.2, 6), ('Contrast', 0.0, 10),\n ('AutoContrast', 0.6, 0)],\n [('Cutout', 0.2, 0), ('Solarize', 0.8, 8), ('Color', 1.0, 4)],\n [('TranslateY_BBox', 0.0, 4), ('Equalize', 0.6, 8),\n ('Solarize', 0.0, 10)],\n [('TranslateY_BBox', 0.2, 2), ('ShearY_BBox', 0.8, 8),\n ('Rotate_BBox', 0.8, 8)],\n [('Cutout', 0.8, 8), ('Brightness', 0.8, 8), ('Cutout', 0.2, 2)],\n [('Color', 0.8, 4), ('TranslateY_BBox', 1.0, 6), ('Rotate_BBox', 0.6, 6)],\n [('Rotate_BBox', 0.6, 10), ('BBox_Cutout', 1.0, 4), ('Cutout', 0.2, 8)],\n [('Rotate_BBox', 0.0, 0), ('Equalize', 0.6, 6), ('ShearY_BBox', 0.6, 8)],\n [('Brightness', 0.8, 8), ('AutoContrast', 0.4, 2),\n ('Brightness', 0.2, 2)],\n [('TranslateY_BBox', 0.4, 8), ('Solarize', 0.4, 6),\n ('SolarizeAdd', 0.2, 10)],\n [('Contrast', 1.0, 10), ('SolarizeAdd', 0.2, 8), ('Equalize', 0.2, 4)],\n ]\n return policy\n\n\ndef policy_v3():\n \"\"\"\"Additional policy that performs well on object detection.\"\"\"\n # Each tuple is an augmentation operation of the form\n # (operation, probability, magnitude). Each element in policy is a\n # sub-policy that will be applied sequentially on the image.\n policy = [\n [('Posterize', 0.8, 2), ('TranslateX_BBox', 1.0, 8)],\n [('BBox_Cutout', 0.2, 10), ('Sharpness', 1.0, 8)],\n [('Rotate_BBox', 0.6, 8), ('Rotate_BBox', 0.8, 10)],\n [('Equalize', 0.8, 10), ('AutoContrast', 0.2, 10)],\n [('SolarizeAdd', 0.2, 2), ('TranslateY_BBox', 0.2, 8)],\n [('Sharpness', 0.0, 2), ('Color', 0.4, 8)],\n [('Equalize', 1.0, 8), ('TranslateY_BBox', 1.0, 8)],\n [('Posterize', 0.6, 2), ('Rotate_BBox', 0.0, 10)],\n [('AutoContrast', 0.6, 0), ('Rotate_BBox', 1.0, 6)],\n # [('Equalize', 0.0, 4), ('Cutout', 0.8, 10)],\n [('Brightness', 1.0, 2), ('TranslateY_BBox', 1.0, 6)],\n [('Contrast', 0.0, 2), ('ShearY_BBox', 0.8, 0)],\n [('AutoContrast', 0.8, 10), ('Contrast', 0.2, 10)],\n # [('Rotate_BBox', 1.0, 10), ('Cutout', 1.0, 10)],\n [('SolarizeAdd', 0.8, 6), ('Equalize', 0.8, 8)],\n ]\n return policy\n\n\ndef blend(image1, image2, factor):\n \"\"\"Blend image1 and image2 using 'factor'.\n\n Factor can be above 0.0. A value of 0.0 means only image1 is used.\n A value of 1.0 means only image2 is used. A value between 0.0 and\n 1.0 means we linearly interpolate the pixel values between the two\n images. A value greater than 1.0 \"extrapolates\" the difference\n between the two pixel values, and we clip the results to values\n between 0 and 255.\n\n Args:\n image1: An image Tensor of type uint8.\n image2: An image Tensor of type uint8.\n factor: A floating point value above 0.0.\n\n Returns:\n A blended image Tensor of type uint8.\n \"\"\"\n if factor == 0.0:\n return tf.convert_to_tensor(image1)\n if factor == 1.0:\n return tf.convert_to_tensor(image2)\n\n image1 = tf.to_float(image1)\n image2 = tf.to_float(image2)\n\n difference = image2 - image1\n scaled = factor * difference\n\n # Do addition in float.\n temp = tf.to_float(image1) + scaled\n\n # Interpolate\n if factor > 0.0 and factor < 1.0:\n # Interpolation means we always stay within 0 and 255.\n return tf.cast(temp, tf.uint8)\n\n # Extrapolate:\n #\n # We need to clip and then cast.\n return tf.cast(tf.clip_by_value(temp, 0.0, 255.0), tf.uint8)\n\n\ndef cutout(image, pad_size, replace=0):\n \"\"\"Apply cutout (https://arxiv.org/abs/1708.04552) to image.\n\n This operation applies a (2*pad_size x 2*pad_size) mask of zeros to\n a random location within `img`. The pixel values filled in will be of the\n value `replace`. The located where the mask will be applied is randomly\n chosen uniformly over the whole image.\n\n Args:\n image: An image Tensor of type uint8.\n pad_size: Specifies how big the zero mask that will be generated is that\n is applied to the image. The mask will be of size\n (2*pad_size x 2*pad_size).\n replace: What pixel value to fill in the image in the area that has\n the cutout mask applied to it.\n\n Returns:\n An image Tensor that is of type uint8.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=0, maxval=image_height,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=0, maxval=image_width,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(0, cutout_center_height - pad_size)\n upper_pad = tf.maximum(0, image_height - cutout_center_height - pad_size)\n left_pad = tf.maximum(0, cutout_center_width - pad_size)\n right_pad = tf.maximum(0, image_width - cutout_center_width - pad_size)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n mask = tf.expand_dims(mask, -1)\n mask = tf.tile(mask, [1, 1, 3])\n image = tf.where(\n tf.equal(mask, 0),\n tf.ones_like(image, dtype=image.dtype) * replace,\n image)\n return image\n\n\ndef solarize(image, threshold=128):\n # For each pixel in the image, select the pixel\n # if the value is less than the threshold.\n # Otherwise, subtract 255 from the pixel.\n return tf.where(image < threshold, image, 255 - image)\n\n\ndef solarize_add(image, addition=0, threshold=128):\n # For each pixel in the image less than threshold\n # we add 'addition' amount to it and then clip the\n # pixel value to be between 0 and 255. The value\n # of 'addition' is between -128 and 128.\n added_image = tf.cast(image, tf.int64) + addition\n added_image = tf.cast(tf.clip_by_value(added_image, 0, 255), tf.uint8)\n return tf.where(image < threshold, added_image, image)\n\n\ndef color(image, factor):\n \"\"\"Equivalent of PIL Color.\"\"\"\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(image))\n return blend(degenerate, image, factor)\n\n\ndef contrast(image, factor):\n \"\"\"Equivalent of PIL Contrast.\"\"\"\n degenerate = tf.image.rgb_to_grayscale(image)\n # Cast before calling tf.histogram.\n degenerate = tf.cast(degenerate, tf.int32)\n\n # Compute the grayscale histogram, then compute the mean pixel value,\n # and create a constant image size of that value. Use that as the\n # blending degenerate target of the original image.\n mean = tf.reduce_mean(tf.cast(degenerate, tf.float32))\n degenerate = tf.ones_like(degenerate, dtype=tf.float32) * mean\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.image.grayscale_to_rgb(tf.cast(degenerate, tf.uint8))\n return blend(degenerate, image, factor)\n\n\ndef brightness(image, factor):\n \"\"\"Equivalent of PIL Brightness.\"\"\"\n degenerate = tf.zeros_like(image)\n return blend(degenerate, image, factor)\n\n\ndef posterize(image, bits):\n \"\"\"Equivalent of PIL Posterize.\"\"\"\n shift = 8 - bits\n return tf.bitwise.left_shift(tf.bitwise.right_shift(image, shift), shift)\n\n\ndef rotate(image, degrees, replace):\n \"\"\"Rotates the image by degrees either clockwise or counterclockwise.\n\n Args:\n image: An image Tensor of type uint8.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels caused by\n the rotate operation.\n\n Returns:\n The rotated version of image.\n \"\"\"\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # In practice, we should randomize the rotation degrees by flipping\n # it negatively half the time, but that's done on 'degrees' outside\n # of the function.\n image = image_ops.rotate(wrap(image), radians)\n return unwrap(image, replace)\n\n\ndef random_shift_bbox(image, bbox, pixel_scaling, replace,\n new_min_bbox_coords=None):\n \"\"\"Move the bbox and the image content to a slightly new random location.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n The potential values for the new min corner of the bbox will be between\n [old_min - pixel_scaling * bbox_height/2,\n old_min - pixel_scaling * bbox_height/2].\n pixel_scaling: A float between 0 and 1 that specifies the pixel range\n that the new bbox location will be sampled from.\n replace: A one or three value 1D tensor to fill empty pixels.\n new_min_bbox_coords: If not None, then this is a tuple that specifies the\n (min_y, min_x) coordinates of the new bbox. Normally this is randomly\n specified, but this allows it to be manually set. The coordinates are\n the absolute coordinates between 0 and image height/width and are int32.\n\n Returns:\n The new image that will have the shifted bbox location in it along with\n the new bbox that contains the new coordinates.\n \"\"\"\n # Obtains image height and width and create helper clip functions.\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n def clip_y(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)\n def clip_x(val):\n return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)\n\n # Convert bbox to pixel coordinates.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = clip_y(tf.to_int32(image_height * bbox[2]))\n max_x = clip_x(tf.to_int32(image_width * bbox[3]))\n bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Select the new min/max bbox ranges that are used for sampling the\n # new min x/y coordinates of the shifted bbox.\n minval_y = clip_y(\n min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n maxval_y = clip_y(\n min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))\n minval_x = clip_x(\n min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n maxval_x = clip_x(\n min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))\n\n # Sample and calculate the new unclipped min/max coordinates of the new bbox.\n if new_min_bbox_coords is None:\n unclipped_new_min_y = tf.random_uniform(\n shape=[], minval=minval_y, maxval=maxval_y,\n dtype=tf.int32)\n unclipped_new_min_x = tf.random_uniform(\n shape=[], minval=minval_x, maxval=maxval_x,\n dtype=tf.int32)\n else:\n unclipped_new_min_y, unclipped_new_min_x = (\n clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))\n unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1\n unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1\n\n # Determine if any of the new bbox was shifted outside the current image.\n # This is used for determining if any of the original bbox content should be\n # discarded.\n new_min_y, new_min_x, new_max_y, new_max_x = (\n clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),\n clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))\n shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y\n shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)\n shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x\n shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)\n\n # Create the new bbox tensor by converting pixel integer values to floats.\n new_bbox = tf.stack([\n tf.to_float(new_min_y) / tf.to_float(image_height),\n tf.to_float(new_min_x) / tf.to_float(image_width),\n tf.to_float(new_max_y) / tf.to_float(image_height),\n tf.to_float(new_max_x) / tf.to_float(image_width)])\n\n # Copy the contents in the bbox and fill the old bbox location\n # with gray (128).\n bbox_content = image[shifted_min_y:shifted_max_y + 1,\n shifted_min_x:shifted_max_x + 1, :]\n\n def mask_and_add_image(\n min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):\n \"\"\"Applies mask to bbox region in image then adds content_tensor to it.\"\"\"\n mask = tf.pad(mask,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=1)\n content_tensor = tf.pad(content_tensor,\n [[min_y_, (image_height - 1) - max_y_],\n [min_x_, (image_width - 1) - max_x_],\n [0, 0]], constant_values=0)\n return image_ * mask + content_tensor\n\n # Zero out original bbox location.\n mask = tf.zeros_like(image)[min_y:max_y+1, min_x:max_x+1, :]\n grey_tensor = tf.zeros_like(mask) + replace[0]\n image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,\n grey_tensor, image)\n\n # Fill in bbox content to new bbox location.\n mask = tf.zeros_like(bbox_content)\n image = mask_and_add_image(new_min_y, new_min_x, new_max_y, new_max_x, mask,\n bbox_content, image)\n\n return image, new_bbox\n\n\ndef _clip_bbox(min_y, min_x, max_y, max_x):\n \"\"\"Clip bounding box coordinates between 0 and 1.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n\n Returns:\n Clipped coordinate values between 0 and 1.\n \"\"\"\n min_y = tf.clip_by_value(min_y, 0.0, 1.0)\n min_x = tf.clip_by_value(min_x, 0.0, 1.0)\n max_y = tf.clip_by_value(max_y, 0.0, 1.0)\n max_x = tf.clip_by_value(max_x, 0.0, 1.0)\n return min_y, min_x, max_y, max_x\n\n\ndef _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):\n \"\"\"Adjusts bbox coordinates to make sure the area is > 0.\n\n Args:\n min_y: Normalized bbox coordinate of type float between 0 and 1.\n min_x: Normalized bbox coordinate of type float between 0 and 1.\n max_y: Normalized bbox coordinate of type float between 0 and 1.\n max_x: Normalized bbox coordinate of type float between 0 and 1.\n delta: Float, this is used to create a gap of size 2 * delta between\n bbox min/max coordinates that are the same on the boundary.\n This prevents the bbox from having an area of zero.\n\n Returns:\n Tuple of new bbox coordinates between 0 and 1 that will now have a\n guaranteed area > 0.\n \"\"\"\n height = max_y - min_y\n width = max_x - min_x\n def _adjust_bbox_boundaries(min_coord, max_coord):\n # Make sure max is never 0 and min is never 1.\n max_coord = tf.maximum(max_coord, 0.0 + delta)\n min_coord = tf.minimum(min_coord, 1.0 - delta)\n return min_coord, max_coord\n min_y, max_y = tf.cond(tf.equal(height, 0.0),\n lambda: _adjust_bbox_boundaries(min_y, max_y),\n lambda: (min_y, max_y))\n min_x, max_x = tf.cond(tf.equal(width, 0.0),\n lambda: _adjust_bbox_boundaries(min_x, max_x),\n lambda: (min_x, max_x))\n return min_y, min_x, max_y, max_x\n\n\ndef _scale_bbox_only_op_probability(prob):\n \"\"\"Reduce the probability of the bbox-only operation.\n\n Probability is reduced so that we do not distort the content of too many\n bounding boxes that are close to each other. The value of 3.0 was a chosen\n hyper parameter when designing the autoaugment algorithm that we found\n empirically to work well.\n\n Args:\n prob: Float that is the probability of applying the bbox-only operation.\n\n Returns:\n Reduced probability.\n \"\"\"\n return prob / 3.0\n\ndef _apply_bbox_augmentation(image, bbox, augmentation_func, *args):\n \"\"\"Applies augmentation_func to the subsection of image indicated by bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where the bbox location in the image will\n have `ugmentation_func applied to it.\n \"\"\"\n image_height = tf.to_float(tf.maximum(tf.shape(image)[0], 10))\n image_width = tf.to_float(tf.maximum(tf.shape(image)[1], 10))\n\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n image_height = tf.to_int32(image_height)\n image_width = tf.to_int32(image_width)\n\n # Clip to be sure the max values do not fall out of range.\n max_y = tf.minimum(max_y, image_height - 1)\n max_x = tf.minimum(max_x, image_width - 1)\n\n # Get the sub-tensor that is the image within the bounding box region.\n bbox_content = image[min_y:max_y + 1, min_x:max_x + 1, :]\n\n # Apply the augmentation function to the bbox portion of the image.\n augmented_bbox_content = augmentation_func(bbox_content, *args)\n\n # Pad the augmented_bbox_content and the mask to match the shape of original\n # image.\n augmented_bbox_content = tf.pad(augmented_bbox_content,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]])\n\n # Create a mask that will be used to zero out a part of the original image.\n mask_tensor = tf.zeros_like(bbox_content)\n\n mask_tensor = tf.pad(mask_tensor,\n [[min_y, (image_height - 1) - max_y],\n [min_x, (image_width - 1) - max_x],\n [0, 0]],\n constant_values=1)\n # Replace the old bbox content with the new augmented content.\n image = image * mask_tensor + augmented_bbox_content\n return image\n\n\ndef _concat_bbox(bbox, bboxes):\n \"\"\"Helper function that concats bbox to bboxes along the first dimension.\"\"\"\n\n # Note if all elements in bboxes are -1 (_INVALID_BOX), then this means\n # we discard bboxes and start the bboxes Tensor with the current bbox.\n bboxes_sum_check = tf.reduce_sum(bboxes)\n bbox = tf.expand_dims(bbox, 0)\n # This check will be true when it is an _INVALID_BOX\n bboxes = tf.cond(tf.equal(bboxes_sum_check, -4.0),\n lambda: bbox,\n lambda: tf.concat([bboxes, bbox], 0))\n return bboxes\n\n\ndef _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,\n augmentation_func, func_changes_bbox,\n *args):\n \"\"\"Applies _apply_bbox_augmentation with probability prob.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n new_bboxes: 2D Tensor that is a list of the bboxes in the image after they\n have been altered by aug_func. These will only be changed when\n func_changes_bbox is set to true. Each bbox has 4 elements\n (min_y, min_x, max_y, max_x) of type float that are the normalized\n bbox coordinates between 0 and 1.\n prob: Float that is the probability of applying _apply_bbox_augmentation.\n augmentation_func: Augmentation function that will be applied to the\n subsection of image.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A tuple. Fist element is a modified version of image, where the bbox\n location in the image will have augmentation_func applied to it if it is\n chosen to be called with probability `prob`. The second element is a\n Tensor of Tensors of length 4 that will contain the altered bbox after\n applying augmentation_func.\n \"\"\"\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n if func_changes_bbox:\n augmented_image, bbox = tf.cond(\n should_apply_op,\n lambda: augmentation_func(image, bbox, *args),\n lambda: (image, bbox))\n else:\n augmented_image = tf.cond(\n should_apply_op,\n lambda: _apply_bbox_augmentation(image, bbox, augmentation_func, *args),\n lambda: image)\n new_bboxes = _concat_bbox(bbox, new_bboxes)\n return augmented_image, new_bboxes\n\n\ndef _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Applies aug_func to the image for each bbox in bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n prob: Float that is the probability of applying aug_func to a specific\n bounding box within the image.\n aug_func: Augmentation function that will be applied to the\n subsections of image indicated by the bbox values in bboxes.\n func_changes_bbox: Boolean. Does augmentation_func return bbox in addition\n to image.\n *args: Additional parameters that will be passed into augmentation_func\n when it is called.\n\n Returns:\n A modified version of image, where each bbox location in the image will\n have augmentation_func applied to it if it is chosen to be called with\n probability prob independently across all bboxes. Also the final\n bboxes are returned that will be unchanged if func_changes_bbox is set to\n false and if true, the new altered ones will be returned.\n \"\"\"\n # Will keep track of the new altered bboxes after aug_func is repeatedly\n # applied. The -1 values are a dummy value and this first Tensor will be\n # removed upon appending the first real bbox.\n new_bboxes = tf.constant(_INVALID_BOX)\n\n # If the bboxes are empty, then just give it _INVALID_BOX. The result\n # will be thrown away.\n bboxes = tf.cond(tf.equal(tf.shape(bboxes)[0], 0),\n lambda: tf.constant(_INVALID_BOX),\n lambda: bboxes)\n\n bboxes = tf.ensure_shape(bboxes, (None, 4))\n\n # pylint:disable=g-long-lambda\n # pylint:disable=line-too-long\n wrapped_aug_func = lambda _image, bbox, _new_bboxes: _apply_bbox_augmentation_wrapper(\n _image, bbox, _new_bboxes, prob, aug_func, func_changes_bbox, *args)\n # pylint:enable=g-long-lambda\n # pylint:enable=line-too-long\n\n # Setup the while_loop.\n num_bboxes = tf.shape(bboxes)[0] # We loop until we go over all bboxes.\n idx = tf.constant(0) # Counter for the while loop.\n\n # Conditional function when to end the loop once we go over all bboxes\n # images_and_bboxes contain (_image, _new_bboxes)\n cond = lambda _idx, _images_and_bboxes: tf.less(_idx, num_bboxes)\n\n # Shuffle the bboxes so that the augmentation order is not deterministic if\n # we are not changing the bboxes with aug_func.\n if not func_changes_bbox:\n loop_bboxes = tf.random.shuffle(bboxes)\n else:\n loop_bboxes = bboxes\n\n # Main function of while_loop where we repeatedly apply augmentation on the\n # bboxes in the image.\n # pylint:disable=g-long-lambda\n body = lambda _idx, _images_and_bboxes: [\n _idx + 1, wrapped_aug_func(_images_and_bboxes[0],\n loop_bboxes[_idx],\n _images_and_bboxes[1])]\n # pylint:enable=g-long-lambda\n\n _, (image, new_bboxes) = tf.while_loop(\n cond, body, [idx, (image, new_bboxes)],\n shape_invariants=[idx.get_shape(),\n (image.get_shape(), tf.TensorShape([None, 4]))])\n\n # Either return the altered bboxes or the original ones depending on if\n # we altered them in anyway.\n if func_changes_bbox:\n final_bboxes = new_bboxes\n else:\n final_bboxes = bboxes\n return image, final_bboxes\n\n\ndef _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,\n func_changes_bbox, *args):\n \"\"\"Checks to be sure num bboxes > 0 before calling inner function.\"\"\"\n num_bboxes = tf.shape(bboxes)[0]\n image, bboxes = tf.cond(\n tf.equal(num_bboxes, 0),\n lambda: (image, bboxes),\n # pylint:disable=g-long-lambda\n lambda: _apply_multi_bbox_augmentation(\n image, bboxes, prob, aug_func, func_changes_bbox, *args))\n # pylint:enable=g-long-lambda\n return image, bboxes\n\n\ndef rotate_only_bboxes(image, bboxes, prob, degrees, replace):\n \"\"\"Apply rotate to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, rotate, func_changes_bbox, degrees, replace)\n\n\ndef shear_x_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_x, func_changes_bbox, level, replace)\n\n\ndef shear_y_only_bboxes(image, bboxes, prob, level, replace):\n \"\"\"Apply shear_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, shear_y, func_changes_bbox, level, replace)\n\n\ndef translate_x_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_x to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_x, func_changes_bbox, pixels, replace)\n\n\ndef translate_y_only_bboxes(image, bboxes, prob, pixels, replace):\n \"\"\"Apply translate_y to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, translate_y, func_changes_bbox, pixels, replace)\n\n\ndef flip_only_bboxes(image, bboxes, prob):\n \"\"\"Apply flip_lr to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, tf.image.flip_left_right, func_changes_bbox)\n\n\ndef solarize_only_bboxes(image, bboxes, prob, threshold):\n \"\"\"Apply solarize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, solarize, func_changes_bbox, threshold)\n\n\ndef equalize_only_bboxes(image, bboxes, prob):\n \"\"\"Apply equalize to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, equalize, func_changes_bbox)\n\n\ndef cutout_only_bboxes(image, bboxes, prob, pad_size, replace):\n \"\"\"Apply cutout to each bbox in the image with probability prob.\"\"\"\n func_changes_bbox = False\n prob = _scale_bbox_only_op_probability(prob)\n return _apply_multi_bbox_augmentation_wrapper(\n image, bboxes, prob, cutout, func_changes_bbox, pad_size, replace)\n\n\ndef _rotate_bbox(bbox, image_height, image_width, degrees):\n \"\"\"Rotates the bbox coordinated by degrees.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n\n Returns:\n A tensor of the same shape as bbox, but now with the rotated coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Convert from degrees to radians.\n degrees_to_radians = math.pi / 180.0\n radians = degrees * degrees_to_radians\n\n # Translate the bbox to the center of the image and turn the normalized 0-1\n # coordinates to absolute pixel locations.\n # Y coordinates are made negative as the y axis of images goes down with\n # increasing pixel values, so we negate to make sure x axis and y axis points\n # are in the traditionally positive direction.\n min_y = -tf.to_int32(image_height * (bbox[0] - 0.5))\n min_x = tf.to_int32(image_width * (bbox[1] - 0.5))\n max_y = -tf.to_int32(image_height * (bbox[2] - 0.5))\n max_x = tf.to_int32(image_width * (bbox[3] - 0.5))\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n # Rotate the coordinates according to the rotation matrix clockwise if\n # radians is positive, else negative\n rotation_matrix = tf.stack(\n [[tf.cos(radians), tf.sin(radians)],\n [-tf.sin(radians), tf.cos(radians)]])\n new_coords = tf.cast(\n tf.matmul(rotation_matrix, tf.transpose(coordinates)), tf.int32)\n # Find min/max values and convert them back to normalized 0-1 floats.\n min_y = -(tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height - 0.5)\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width + 0.5\n max_y = -(tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height - 0.5)\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width + 0.5\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef rotate_with_bboxes(image, bboxes, degrees, replace):\n \"\"\"Equivalent of PIL Rotate that rotates the image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float.\n degrees: Float, a scalar angle in degrees to rotate all images by. If\n degrees is positive the image will be rotated clockwise otherwise it will\n be rotated counterclockwise.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of rotating\n image by degrees. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the rotated image.\n \"\"\"\n # Rotate the image.\n image = rotate(image, degrees, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_rotate_bbox = lambda bbox: _rotate_bbox(\n bbox, image_height, image_width, degrees)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_rotate_bbox, bboxes)\n return image, bboxes\n\n\ndef translate_x(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in X dimension.\"\"\"\n image = image_ops.translate(wrap(image), [-pixels, 0])\n return unwrap(image, replace)\n\n\ndef translate_y(image, pixels, replace):\n \"\"\"Equivalent of PIL Translate in Y dimension.\"\"\"\n image = image_ops.translate(wrap(image), [0, -pixels])\n return unwrap(image, replace)\n\n\ndef _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):\n \"\"\"Shifts the bbox coordinates by pixels.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, width of the image.\n pixels: An int. How many pixels to shift the bbox.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n pixels = tf.to_int32(pixels)\n # Convert bbox to integer pixel locations.\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n if shift_horizontal:\n min_x = tf.maximum(0, min_x - pixels)\n max_x = tf.minimum(image_width, max_x - pixels)\n else:\n min_y = tf.maximum(0, min_y - pixels)\n max_y = tf.minimum(image_height, max_y - pixels)\n\n # Convert bbox back to floats.\n min_y = tf.to_float(min_y) / tf.to_float(image_height)\n min_x = tf.to_float(min_x) / tf.to_float(image_width)\n max_y = tf.to_float(max_y) / tf.to_float(image_height)\n max_x = tf.to_float(max_x) / tf.to_float(image_width)\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef translate_bbox(image, bboxes, pixels, replace, shift_horizontal):\n \"\"\"Equivalent of PIL Translate in X/Y dimension that shifts image and bbox.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pixels: An int. How many pixels to shift the image and bboxes\n replace: A one or three value 1D tensor to fill empty pixels.\n shift_horizontal: Boolean. If true then shift in X dimension else shift in\n Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of translating\n image by pixels. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the shifted image.\n \"\"\"\n if shift_horizontal:\n image = translate_x(image, pixels, replace)\n else:\n image = translate_y(image, pixels, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shift_bbox = lambda bbox: _shift_bbox(\n bbox, image_height, image_width, pixels, shift_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shift_bbox, bboxes)\n return image, bboxes\n\n\ndef shear_x(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in X dimension.\"\"\"\n # Shear parallel to x axis is a projective transform\n # with a matrix form of:\n # [1 level\n # 0 1].\n image = image_ops.transform(\n wrap(image), [1., level, 0., 0., 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef shear_y(image, level, replace):\n \"\"\"Equivalent of PIL Shearing in Y dimension.\"\"\"\n # Shear parallel to y axis is a projective transform\n # with a matrix form of:\n # [1 0\n # level 1].\n image = image_ops.transform(\n wrap(image), [1., 0., 0., level, 1., 0., 0., 0.])\n return unwrap(image, replace)\n\n\ndef _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):\n \"\"\"Shifts the bbox according to how the image was sheared.\n\n Args:\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n image_height: Int, height of the image.\n image_width: Int, height of the image.\n level: Float. How much to shear the image.\n shear_horizontal: If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tensor of the same shape as bbox, but now with the shifted coordinates.\n \"\"\"\n image_height, image_width = (\n tf.to_float(image_height), tf.to_float(image_width))\n\n # Change bbox coordinates to be pixels.\n min_y = tf.to_int32(image_height * bbox[0])\n min_x = tf.to_int32(image_width * bbox[1])\n max_y = tf.to_int32(image_height * bbox[2])\n max_x = tf.to_int32(image_width * bbox[3])\n coordinates = tf.stack(\n [[min_y, min_x], [min_y, max_x], [max_y, min_x], [max_y, max_x]])\n coordinates = tf.cast(coordinates, tf.float32)\n\n # Shear the coordinates according to the translation matrix.\n if shear_horizontal:\n translation_matrix = tf.stack(\n [[1, 0], [-level, 1]])\n else:\n translation_matrix = tf.stack(\n [[1, -level], [0, 1]])\n translation_matrix = tf.cast(translation_matrix, tf.float32)\n new_coords = tf.cast(\n tf.matmul(translation_matrix, tf.transpose(coordinates)), tf.int32)\n\n # Find min/max values and convert them back to floats.\n min_y = tf.to_float(tf.reduce_min(new_coords[0, :])) / image_height\n min_x = tf.to_float(tf.reduce_min(new_coords[1, :])) / image_width\n max_y = tf.to_float(tf.reduce_max(new_coords[0, :])) / image_height\n max_x = tf.to_float(tf.reduce_max(new_coords[1, :])) / image_width\n\n # Clip the bboxes to be sure the fall between [0, 1].\n min_y, min_x, max_y, max_x = _clip_bbox(min_y, min_x, max_y, max_x)\n min_y, min_x, max_y, max_x = _check_bbox_area(min_y, min_x, max_y, max_x)\n return tf.stack([min_y, min_x, max_y, max_x])\n\n\ndef shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):\n \"\"\"Applies Shear Transformation to the image and shifts the bboxes.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n level: Float. How much to shear the image. This value will be between\n -0.3 to 0.3.\n replace: A one or three value 1D tensor to fill empty pixels.\n shear_horizontal: Boolean. If true then shear in X dimension else shear in\n the Y dimension.\n\n Returns:\n A tuple containing a 3D uint8 Tensor that will be the result of shearing\n image by level. The second element of the tuple is bboxes, where now\n the coordinates will be shifted to reflect the sheared image.\n \"\"\"\n if shear_horizontal:\n image = shear_x(image, level, replace)\n else:\n image = shear_y(image, level, replace)\n\n # Convert bbox coordinates to pixel values.\n image_height = tf.shape(image)[0]\n image_width = tf.shape(image)[1]\n # pylint:disable=g-long-lambda\n wrapped_shear_bbox = lambda bbox: _shear_bbox(\n bbox, image_height, image_width, level, shear_horizontal)\n # pylint:enable=g-long-lambda\n bboxes = tf.map_fn(wrapped_shear_bbox, bboxes)\n return image, bboxes\n\n\ndef autocontrast(image):\n \"\"\"Implements Autocontrast function from PIL using TF ops.\n\n Args:\n image: A 3D uint8 tensor.\n\n Returns:\n The image after it has had autocontrast applied to it and will be of type\n uint8.\n \"\"\"\n\n def scale_channel(image):\n \"\"\"Scale the 2D image using the autocontrast rule.\"\"\"\n # A possibly cheaper version can be done using cumsum/unique_with_counts\n # over the histogram values, rather than iterating over the entire image.\n # to compute mins and maxes.\n lo = tf.to_float(tf.reduce_min(image))\n hi = tf.to_float(tf.reduce_max(image))\n\n # Scale the image, making the lowest value 0 and the highest value 255.\n def scale_values(im):\n scale = 255.0 / (hi - lo)\n offset = -lo * scale\n im = tf.to_float(im) * scale + offset\n im = tf.clip_by_value(im, 0.0, 255.0)\n return tf.cast(im, tf.uint8)\n\n result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image)\n return result\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image[:, :, 0])\n s2 = scale_channel(image[:, :, 1])\n s3 = scale_channel(image[:, :, 2])\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef sharpness(image, factor):\n \"\"\"Implements Sharpness function from PIL using TF ops.\"\"\"\n orig_image = image\n image = tf.cast(image, tf.float32)\n # Make image 4D for conv operation.\n image = tf.expand_dims(image, 0)\n # SMOOTH PIL Kernel.\n kernel = tf.constant(\n [[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=tf.float32,\n shape=[3, 3, 1, 1]) / 13.\n # Tile across channel dimension.\n kernel = tf.tile(kernel, [1, 1, 3, 1])\n strides = [1, 1, 1, 1]\n with tf.device('/cpu:0'):\n degenerate = tf.nn.depthwise_conv2d(\n image, kernel, strides, padding='VALID', rate=[1, 1])\n degenerate = tf.clip_by_value(degenerate, 0.0, 255.0)\n degenerate = tf.squeeze(tf.cast(degenerate, tf.uint8), [0])\n\n # For the borders of the resulting image, fill in the values of the\n # original image.\n mask = tf.ones_like(degenerate)\n padded_mask = tf.pad(mask, [[1, 1], [1, 1], [0, 0]])\n padded_degenerate = tf.pad(degenerate, [[1, 1], [1, 1], [0, 0]])\n result = tf.where(tf.equal(padded_mask, 1), padded_degenerate, orig_image)\n\n # Blend the final result.\n return blend(result, orig_image, factor)\n\n\ndef equalize(image):\n \"\"\"Implements Equalize function from PIL using TF ops.\"\"\"\n def scale_channel(im, c):\n \"\"\"Scale the data in the channel to implement equalize.\"\"\"\n im = tf.cast(im[:, :, c], tf.int32)\n # Compute the histogram of the image channel.\n histo = tf.histogram_fixed_width(im, [0, 255], nbins=256)\n\n # For the purposes of computing the step, filter out the nonzeros.\n nonzero = tf.where(tf.not_equal(histo, 0))\n nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1])\n step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255\n\n def build_lut(histo, step):\n # Compute the cumulative sum, shifting by step // 2\n # and then normalization by step.\n lut = (tf.cumsum(histo) + (step // 2)) // step\n # Shift lut, prepending with 0.\n lut = tf.concat([[0], lut[:-1]], 0)\n # Clip the counts to be in range. This is done\n # in the C code for image.point.\n return tf.clip_by_value(lut, 0, 255)\n\n # If step is zero, return the original image. Otherwise, build\n # lut from the full histogram and step and then index from it.\n result = tf.cond(tf.equal(step, 0),\n lambda: im,\n lambda: tf.gather(build_lut(histo, step), im))\n\n return tf.cast(result, tf.uint8)\n\n # Assumes RGB for now. Scales each channel independently\n # and then stacks the result.\n s1 = scale_channel(image, 0)\n s2 = scale_channel(image, 1)\n s3 = scale_channel(image, 2)\n image = tf.stack([s1, s2, s3], 2)\n return image\n\n\ndef wrap(image):\n \"\"\"Returns 'image' with an extra channel set to all 1s.\"\"\"\n shape = tf.shape(image)\n extended_channel = tf.ones([shape[0], shape[1], 1], image.dtype)\n extended = tf.concat([image, extended_channel], 2)\n return extended\n\n\ndef unwrap(image, replace):\n \"\"\"Unwraps an image produced by wrap.\n\n Where there is a 0 in the last channel for every spatial position,\n the rest of the three channels in that spatial dimension are grayed\n (set to 128). Operations like translate and shear on a wrapped\n Tensor will leave 0s in empty locations. Some transformations look\n at the intensity of values to do preprocessing, and we want these\n empty pixels to assume the 'average' value, rather than pure black.\n\n\n Args:\n image: A 3D Image Tensor with 4 channels.\n replace: A one or three value 1D tensor to fill empty pixels.\n\n Returns:\n image: A 3D image Tensor with 3 channels.\n \"\"\"\n image_shape = tf.shape(image)\n # Flatten the spatial dimensions.\n flattened_image = tf.reshape(image, [-1, image_shape[2]])\n\n # Find all pixels where the last channel is zero.\n alpha_channel = flattened_image[:, 3]\n\n replace = tf.concat([replace, tf.ones([1], image.dtype)], 0)\n\n # Where they are zero, fill them in with 'replace'.\n flattened_image = tf.where(\n tf.equal(alpha_channel, 0),\n tf.ones_like(flattened_image, dtype=image.dtype) * replace,\n flattened_image)\n\n image = tf.reshape(flattened_image, image_shape)\n image = tf.slice(image, [0, 0, 0], [image_shape[0], image_shape[1], 3])\n return image\n\n\ndef _cutout_inside_bbox(image, bbox, pad_fraction):\n \"\"\"Generates cutout mask and the mean pixel value of the bbox.\n\n First a location is randomly chosen within the image as the center where the\n cutout mask will be applied. Note this can be towards the boundaries of the\n image, so the full cutout mask may not be applied.\n\n Args:\n image: 3D uint8 Tensor.\n bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)\n of type float that represents the normalized coordinates between 0 and 1.\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n\n Returns:\n A tuple. Fist element is a tensor of the same shape as image where each\n element is either a 1 or 0 that is used to determine where the image\n will have cutout applied. The second element is the mean of the pixels\n in the image where the bbox is located.\n \"\"\"\n image_height = tf.maximum(tf.shape(image)[0], 10)\n image_width = tf.maximum(tf.shape(image)[1], 10)\n # Transform from shape [1, 4] to [4].\n bbox = tf.squeeze(bbox)\n\n min_y = tf.to_int32(tf.to_float(image_height) * bbox[0])\n min_x = tf.to_int32(tf.to_float(image_width) * bbox[1])\n max_y = tf.to_int32(tf.to_float(image_height) * bbox[2])\n max_x = tf.to_int32(tf.to_float(image_width) * bbox[3])\n\n # Calculate the mean pixel values in the bounding box, which will be used\n # to fill the cutout region.\n mean = tf.reduce_mean(image[min_y:max_y + 1, min_x:max_x + 1],\n reduction_indices=[0, 1])\n\n # Cutout mask will be size pad_size_heigh * 2 by pad_size_width * 2 if the\n # region lies entirely within the bbox.\n box_height = max_y - min_y + 1\n box_width = max_x - min_x + 1\n pad_size_height = tf.to_int32(pad_fraction * (box_height / 2))\n pad_size_width = tf.to_int32(pad_fraction * (box_width / 2))\n\n # Sample the center location in the image where the zero mask will be applied.\n cutout_center_height = tf.random_uniform(\n shape=[], minval=min_y, maxval=max_y+1,\n dtype=tf.int32)\n\n cutout_center_width = tf.random_uniform(\n shape=[], minval=min_x, maxval=max_x+1,\n dtype=tf.int32)\n\n lower_pad = tf.maximum(\n 0, cutout_center_height - pad_size_height)\n upper_pad = tf.maximum(\n 0, image_height - cutout_center_height - pad_size_height)\n left_pad = tf.maximum(\n 0, cutout_center_width - pad_size_width)\n right_pad = tf.maximum(\n 0, image_width - cutout_center_width - pad_size_width)\n\n cutout_shape = [image_height - (lower_pad + upper_pad),\n image_width - (left_pad + right_pad)]\n padding_dims = [[lower_pad, upper_pad], [left_pad, right_pad]]\n\n mask = tf.pad(\n tf.zeros(cutout_shape, dtype=image.dtype),\n padding_dims, constant_values=1)\n\n mask = tf.expand_dims(mask, 2)\n mask = tf.tile(mask, [1, 1, 3])\n\n return mask, mean\n\n\ndef bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):\n \"\"\"Applies cutout to the image according to bbox information.\n\n This is a cutout variant that using bbox information to make more informed\n decisions on where to place the cutout mask.\n\n Args:\n image: 3D uint8 Tensor.\n bboxes: 2D Tensor that is a list of the bboxes in the image. Each bbox\n has 4 elements (min_y, min_x, max_y, max_x) of type float with values\n between [0, 1].\n pad_fraction: Float that specifies how large the cutout mask should be in\n in reference to the size of the original bbox. If pad_fraction is 0.25,\n then the cutout mask will be of shape\n (0.25 * bbox height, 0.25 * bbox width).\n replace_with_mean: Boolean that specified what value should be filled in\n where the cutout mask is applied. Since the incoming image will be of\n uint8 and will not have had any mean normalization applied, by default\n we set the value to be 128. If replace_with_mean is True then we find\n the mean pixel values across the channel dimension and use those to fill\n in where the cutout mask is applied.\n\n Returns:\n A tuple. First element is a tensor of the same shape as image that has\n cutout applied to it. Second element is the bboxes that were passed in\n that will be unchanged.\n \"\"\"\n def apply_bbox_cutout(image, bboxes, pad_fraction):\n \"\"\"Applies cutout to a single bounding box within image.\"\"\"\n # Choose a single bounding box to apply cutout to.\n random_index = tf.random_uniform(\n shape=[], maxval=tf.shape(bboxes)[0], dtype=tf.int32)\n # Select the corresponding bbox and apply cutout.\n chosen_bbox = tf.gather(bboxes, random_index)\n mask, mean = _cutout_inside_bbox(image, chosen_bbox, pad_fraction)\n\n # When applying cutout we either set the pixel value to 128 or to the mean\n # value inside the bbox.\n replace = mean if replace_with_mean else 128\n\n # Apply the cutout mask to the image. Where the mask is 0 we fill it with\n # `replace`.\n image = tf.where(\n tf.equal(mask, 0),\n tf.cast(tf.ones_like(image, dtype=image.dtype) * replace,\n dtype=image.dtype),\n image)\n return image\n\n # Check to see if there are boxes, if so then apply boxcutout.\n image = tf.cond(tf.equal(tf.shape(bboxes)[0], 0), lambda: image,\n lambda: apply_bbox_cutout(image, bboxes, pad_fraction))\n\n return image, bboxes\n\n\nNAME_TO_FUNC = {\n 'AutoContrast': autocontrast,\n 'Equalize': equalize,\n 'Posterize': posterize,\n 'Solarize': solarize,\n 'SolarizeAdd': solarize_add,\n 'Color': color,\n 'Contrast': contrast,\n 'Brightness': brightness,\n 'Sharpness': sharpness,\n 'Cutout': cutout,\n 'BBox_Cutout': bbox_cutout,\n 'Rotate_BBox': rotate_with_bboxes,\n # pylint:disable=g-long-lambda\n 'TranslateX_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=True),\n 'TranslateY_BBox': lambda image, bboxes, pixels, replace: translate_bbox(\n image, bboxes, pixels, replace, shift_horizontal=False),\n 'ShearX_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=True),\n 'ShearY_BBox': lambda image, bboxes, level, replace: shear_with_bboxes(\n image, bboxes, level, replace, shear_horizontal=False),\n # pylint:enable=g-long-lambda\n 'Rotate_Only_BBoxes': rotate_only_bboxes,\n 'ShearX_Only_BBoxes': shear_x_only_bboxes,\n 'ShearY_Only_BBoxes': shear_y_only_bboxes,\n 'TranslateX_Only_BBoxes': translate_x_only_bboxes,\n 'TranslateY_Only_BBoxes': translate_y_only_bboxes,\n 'Flip_Only_BBoxes': flip_only_bboxes,\n 'Solarize_Only_BBoxes': solarize_only_bboxes,\n 'Equalize_Only_BBoxes': equalize_only_bboxes,\n 'Cutout_Only_BBoxes': cutout_only_bboxes,\n}\n\n\ndef _randomly_negate_tensor(tensor):\n \"\"\"With 50% prob turn the tensor negative.\"\"\"\n should_flip = tf.cast(tf.floor(tf.random_uniform([]) + 0.5), tf.bool)\n final_tensor = tf.cond(should_flip, lambda: tensor, lambda: -tensor)\n return final_tensor\n\n\ndef _rotate_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 30.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _shrink_level_to_arg(level):\n \"\"\"Converts level to ratio by which we shrink the image content.\"\"\"\n if level == 0:\n return (1.0,) # if level is zero, do not shrink the image\n # Maximum shrinking ratio is 2.9.\n level = 2. / (_MAX_LEVEL / level) + 0.9\n return (level,)\n\n\ndef _enhance_level_to_arg(level):\n return ((level/_MAX_LEVEL) * 1.8 + 0.1,)\n\n\ndef _shear_level_to_arg(level):\n level = (level/_MAX_LEVEL) * 0.3\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _translate_level_to_arg(level, translate_const):\n level = (level/_MAX_LEVEL) * float(translate_const)\n # Flip level to negative with 50% chance.\n level = _randomly_negate_tensor(level)\n return (level,)\n\n\ndef _bbox_cutout_level_to_arg(level, hparams):\n cutout_pad_fraction = (level/_MAX_LEVEL) * hparams.cutout_max_pad_fraction\n return (cutout_pad_fraction,\n hparams.cutout_bbox_replace_with_mean)\n\n\ndef level_to_arg(hparams):\n return {\n 'AutoContrast': lambda level: (),\n 'Equalize': lambda level: (),\n 'Posterize': lambda level: (int((level/_MAX_LEVEL) * 4),),\n 'Solarize': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'SolarizeAdd': lambda level: (int((level/_MAX_LEVEL) * 110),),\n 'Color': _enhance_level_to_arg,\n 'Contrast': _enhance_level_to_arg,\n 'Brightness': _enhance_level_to_arg,\n 'Sharpness': _enhance_level_to_arg,\n 'Cutout': lambda level: (int((level/_MAX_LEVEL) * hparams.cutout_const),),\n # pylint:disable=g-long-lambda\n 'BBox_Cutout': lambda level: _bbox_cutout_level_to_arg(\n level, hparams),\n 'TranslateX_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n 'TranslateY_BBox': lambda level: _translate_level_to_arg(\n level, hparams.translate_const),\n # pylint:enable=g-long-lambda\n 'ShearX_BBox': _shear_level_to_arg,\n 'ShearY_BBox': _shear_level_to_arg,\n 'Rotate_BBox': _rotate_level_to_arg,\n 'Rotate_Only_BBoxes': _rotate_level_to_arg,\n 'ShearX_Only_BBoxes': _shear_level_to_arg,\n 'ShearY_Only_BBoxes': _shear_level_to_arg,\n # pylint:disable=g-long-lambda\n 'TranslateX_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n 'TranslateY_Only_BBoxes': lambda level: _translate_level_to_arg(\n level, hparams.translate_bbox_const),\n # pylint:enable=g-long-lambda\n 'Flip_Only_BBoxes': lambda level: (),\n 'Solarize_Only_BBoxes': lambda level: (int((level/_MAX_LEVEL) * 256),),\n 'Equalize_Only_BBoxes': lambda level: (),\n # pylint:disable=g-long-lambda\n 'Cutout_Only_BBoxes': lambda level: (\n int((level/_MAX_LEVEL) * hparams.cutout_bbox_const),),\n # pylint:enable=g-long-lambda\n }\n\n\ndef bbox_wrapper(func):\n \"\"\"Adds a bboxes function argument to func and returns unchanged bboxes.\"\"\"\n def wrapper(images, bboxes, *args, **kwargs):\n return (func(images, *args, **kwargs), bboxes)\n return wrapper\n\n\ndef _parse_policy_info(name, prob, level, replace_value, augmentation_hparams):\n \"\"\"Return the function that corresponds to `name` and update `level` param.\"\"\"\n func = NAME_TO_FUNC[name]\n args = level_to_arg(augmentation_hparams)[name](level)\n\n # Check to see if prob is passed into function. This is used for operations\n # where we alter bboxes independently.\n # pytype:disable=wrong-arg-types\n if 'prob' in inspect.getfullargspec(func)[0]:\n args = tuple([prob] + list(args))\n # pytype:enable=wrong-arg-types\n\n # Add in replace arg if it is required for the function that is being called.\n if 'replace' in inspect.getfullargspec(func)[0]:\n # Make sure replace is the final argument\n assert 'replace' == inspect.getfullargspec(func)[0][-1]\n args = tuple(list(args) + [replace_value])\n\n # Add bboxes as the second positional argument for the function if it does\n # not already exist.\n if 'bboxes' not in inspect.getfullargspec(func)[0]:\n func = bbox_wrapper(func)\n return (func, prob, args)\n\n\ndef _apply_func_with_prob(func, image, args, prob, bboxes):\n \"\"\"Apply `func` to image w/ `args` as input with probability `prob`.\"\"\"\n assert isinstance(args, tuple)\n assert 'bboxes' == inspect.getfullargspec(func)[0][1]\n\n # If prob is a function argument, then this randomness is being handled\n # inside the function, so make sure it is always called.\n if 'prob' in inspect.getfullargspec(func)[0]:\n prob = 1.0\n\n # Apply the function with probability `prob`.\n should_apply_op = tf.cast(\n tf.floor(tf.random_uniform([], dtype=tf.float32) + prob), tf.bool)\n augmented_image, augmented_bboxes = tf.cond(\n should_apply_op,\n lambda: func(image, bboxes, *args),\n lambda: (image, bboxes))\n return augmented_image, augmented_bboxes\n\n\ndef select_and_apply_random_policy(policies, image, bboxes):\n \"\"\"Select a random policy from `policies` and apply it to `image`.\"\"\"\n policy_to_select = tf.random_uniform([], maxval=len(policies), dtype=tf.int32)\n # Note that using tf.case instead of tf.conds would result in significantly\n # larger graphs and would even break export for some larger policies.\n for (i, policy) in enumerate(policies):\n image, bboxes = tf.cond(\n tf.equal(i, policy_to_select),\n lambda selected_policy=policy: selected_policy(image, bboxes),\n lambda: (image, bboxes))\n return (image, bboxes)\n\n\ndef build_and_apply_nas_policy(policies, image, bboxes,\n augmentation_hparams):\n \"\"\"Build a policy from the given policies passed in and apply to image.\n\n Args:\n policies: list of lists of tuples in the form `(func, prob, level)`, `func`\n is a string name of the augmentation function, `prob` is the probability\n of applying the `func` operation, `level` is the input argument for\n `func`.\n image: tf.Tensor that the resulting policy will be applied to.\n bboxes: tf.Tensor of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_hparams: Hparams associated with the NAS learned policy.\n\n Returns:\n A version of image that now has data augmentation applied to it based on\n the `policies` pass into the function. Additionally, returns bboxes if\n a value for them is passed in that is not None\n \"\"\"\n replace_value = [128, 128, 128]\n\n # func is the string name of the augmentation function, prob is the\n # probability of applying the operation and level is the parameter associated\n # with the tf op.\n\n # tf_policies are functions that take in an image and return an augmented\n # image.\n tf_policies = []\n for policy in policies:\n tf_policy = []\n # Link string name to the correct python function and make sure the correct\n # argument is passed into that function.\n for policy_info in policy:\n policy_info = list(policy_info) + [replace_value, augmentation_hparams]\n\n tf_policy.append(_parse_policy_info(*policy_info))\n # Now build the tf policy that will apply the augmentation procedue\n # on image.\n def make_final_policy(tf_policy_):\n def final_policy(image_, bboxes_):\n for func, prob, args in tf_policy_:\n image_, bboxes_ = _apply_func_with_prob(\n func, image_, args, prob, bboxes_)\n return image_, bboxes_\n return final_policy\n tf_policies.append(make_final_policy(tf_policy))\n augmented_images, augmented_bboxes = select_and_apply_random_policy(\n tf_policies, image, bboxes)\n\n # If no bounding boxes were specified, then just return the images.\n return (augmented_images, augmented_bboxes)\n\n\n@tf.autograph.experimental.do_not_convert\ndef distort_image_with_autoaugment(image,\n bboxes,\n augmentation_name):\n \"\"\"Applies the AutoAugment policy to `image` and `bboxes`.\n\n Args:\n image: `Tensor` of shape [height, width, 3] representing an image.\n bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are\n normalized between [0, 1].\n augmentation_name: The name of the AutoAugment policy to use. The available\n options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for\n all of the results in the paper and was found to achieve the best results\n on the COCO dataset. `v1`, `v2` and `v3` are additional good policies\n found on the COCO dataset that have slight variation in what operations\n were used during the search procedure along with how many operations are\n applied in parallel to a single image (2 vs 3).\n\n Returns:\n A tuple containing the augmented versions of `image` and `bboxes`.\n \"\"\"\n logging.info('Using autoaugmention policy: %s', augmentation_name)\n available_policies = {'v0': policy_v0, 'v1': policy_v1, 'v2': policy_v2,\n 'v3': policy_v3, 'test': policy_vtest}\n if augmentation_name not in available_policies:\n raise ValueError('Invalid augmentation_name: {}'.format(augmentation_name))\n\n policy = available_policies[augmentation_name]()\n # Hparams that will be used for AutoAugment.\n augmentation_hparams = hparams_config.Config(dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n return build_and_apply_nas_policy(policy, image, bboxes,\n augmentation_hparams)\n\n\ndef distort_image_with_randaugment(image, bboxes, num_layers, magnitude):\n \"\"\"Applies the RandAugment to `image` and `bboxes`.\"\"\"\n replace_value = [128, 128, 128]\n tf.logging.info('Using RandAugment.')\n\n augmentation_hparams = hparams_config.Config(\n dict(\n cutout_max_pad_fraction=0.75,\n cutout_bbox_replace_with_mean=False,\n cutout_const=100,\n translate_const=250,\n cutout_bbox_const=50,\n translate_bbox_const=120))\n\n available_ops = [\n 'Equalize', 'Solarize', 'Color', 'Cutout', 'SolarizeAdd',\n 'TranslateX_BBox', 'TranslateY_BBox', 'ShearX_BBox', 'ShearY_BBox',\n 'Rotate_BBox']\n\n if bboxes is None:\n bboxes = tf.constant(0.0)\n\n for layer_num in range(num_layers):\n op_to_select = tf.random_uniform(\n [], maxval=len(available_ops), dtype=tf.int32)\n random_magnitude = float(magnitude)\n with tf.name_scope('randaug_layer_{}'.format(layer_num)):\n for (i, op_name) in enumerate(available_ops):\n prob = tf.random_uniform([], minval=0.2, maxval=0.8, dtype=tf.float32)\n func, _, args = _parse_policy_info(op_name, prob, random_magnitude,\n replace_value, augmentation_hparams)\n image, bboxes = tf.cond(\n tf.equal(i, op_to_select),\n lambda fn=func, fn_args=args: fn(image, bboxes, *fn_args),\n lambda: (image, bboxes))\n return (image, bboxes)\n"}}},{"rowIdx":2083,"cells":{"function_name":{"kind":"string","value":"get_hgmo_archive"},"docstring":{"kind":"string","value":"An archiver for hg.mozilla.org related requests. Uses relengapi.blueprints.archiver.get_archive\n\n:param repo: the repo location off of hg.mozilla.org/\n:param rev: the rev associated with the repo\n:param subdir: optional subdir path to only archive a portion of the repo\n:param suffix: the archive extension type. defaulted to tar.gz\n:param preferred_region: the preferred s3 region to use"},"masked_code":{"kind":"string","value":"# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not distributed with this\n# file, You can obtain one at http://mozilla.org/MPL/2.0/.\n\nimport logging\n\n\nimport datetime\nimport sqlalchemy as sa\n\nfrom random import randint\n\nfrom flask import Blueprint\nfrom flask import current_app\nfrom flask import redirect\nfrom flask import url_for\n\nfrom relengapi.blueprints.archiver import tables\nfrom relengapi.blueprints.archiver.tasks import TASK_TIME_OUT\nfrom relengapi.blueprints.archiver.tasks import create_and_upload_archive\nfrom relengapi.blueprints.archiver.types import MozharnessArchiveTask\nfrom relengapi.lib import api\nfrom relengapi.lib import badpenny\nfrom relengapi.lib.time import now\n\nbp = Blueprint('archiver', __name__)\nlog = logging.getLogger(__name__)\n\nGET_EXPIRES_IN = 300\nPENDING_EXPIRES_IN = 60\nFINISHED_STATES = ['SUCCESS', 'FAILURE', 'REVOKED']\n\n\ndef delete_tracker(tracker):\n session = current_app.db.session('relengapi')\n log.info(\"deleting tracker with id: {}\".format(tracker.task_id))\n session.delete(tracker)\n session.commit()\n\n\ndef update_tracker_state(tracker, state):\n session = current_app.db.session('relengapi')\n log.info(\"updating tracker with id: {} to state: {}\".format(tracker.id, state))\n try:\n tracker.state = state\n session.commit()\n except sa.exc.IntegrityError:\n session.rollback()\n\n\n@badpenny.periodic_task(seconds=TASK_TIME_OUT)\ndef cleanup_old_tasks(job_status):\n \"\"\"delete any tracker task if it is older than the time a task can live for.\"\"\"\n session = current_app.db.session('relengapi')\n expiry_cutoff = now() - datetime.timedelta(seconds=TASK_TIME_OUT)\n table = tables.ArchiverTask\n for tracker in session.query(table).order_by(table.created_at):\n if tracker.created_at < expiry_cutoff:\n delete_tracker(tracker)\n else:\n break\n\n\ndef renew_tracker_pending_expiry(tracker):\n pending_expires_at = now() + datetime.timedelta(seconds=PENDING_EXPIRES_IN)\n session = current_app.db.session('relengapi')\n log.info(\"renewing tracker {} with pending expiry: {}\".format(tracker.id, pending_expires_at))\n tracker.pending_expires_at = pending_expires_at\n session.commit()\n\n\n@bp.route('/status/<task_id>')\n@api.apimethod(MozharnessArchiveTask, unicode)\ndef task_status(task_id):\n \"\"\"\n Check and return the current state of the create_and_upload_archive celery task with task id\n of <task_id>.\n\n If the task is unknown, state will be PENDING. Once the task starts it will be updated to\n STARTED and finally, if it completes, it will be either SUCCESS (no exceptions), or FAILURE.\n\n See update_state() within create_and_upload_archive and\n http://celery.readthedocs.org/en/latest/reference/celery.states.html for more details.\n\n If state is SUCCESS, it is safe to check response['s3_urls'] for the archives submitted to s3\n \"\"\"\n task = create_and_upload_archive.AsyncResult(task_id)\n task_tracker = tables.ArchiverTask.query.filter(tables.ArchiverTask.task_id == task_id).first()\n log.info(\"checking status of task id {}: current state {}\".format(task_id, task.state))\n task_info = task.info or {}\n response = {\n 'state': task.state,\n }\n if task.state != 'FAILURE':\n response['status'] = task_info.get('status', 'no status available at this point.')\n response['src_url'] = task_info.get('src_url', '')\n response['s3_urls'] = task_info.get('s3_urls', {})\n else:\n # something went wrong\n response['status'] = str(task.info) # this is the exception raised\n response['src_url'] = ''\n response['s3_urls'] = {}\n\n # archiver does not create any custom states, so we can assume to have only the defaults:\n # http://docs.celeryproject.org/en/latest/userguide/tasks.html#task-states\n # therefore, delete our state_id tracker from the db if the celery state is in a final state:\n # e.g. not RETRY, STARTED, or PENDING\n if task_tracker:\n if task.state in FINISHED_STATES:\n delete_tracker(task_tracker)\n elif task.state == \"PENDING\" and task_tracker.pending_expires_at < now():\n log.info(\"Task {} has expired from pending too long. Re-creating task\".format(task.id))\n renew_tracker_pending_expiry(task_tracker) # let exceptions bubble up before moving on\n create_and_upload_archive.apply_async(args=[task_tracker.src_url, task_tracker.s3_key],\n task_id=task.id)\n response['state'] = 'RETRY'\n response['status'] = 'Task has expired from pending for too long. Re-creating task.'\n elif task_tracker.state != task.state:\n update_tracker_state(task_tracker, task.state)\n\n return MozharnessArchiveTask(**response)\n\n\n# MASKED: get_hgmo_archive function (lines 124-147)\n\n\ndef get_archive(src_url, key, preferred_region):\n \"\"\"\n A generic getter for retrieving an s3 location of an archive where the archive is based off a\n src_url.\n\n sub-dir: hg.mozilla.org supports archives of sub directories within a repository. This\n flexibility allows for creating archives of only a portion of what would normally be an entire\n repo archive.\n\n logic flow:\n If their is already a key within s3, a re-direct link is given for the\n s3 location. If the key does not exist, download the archive from src url, upload it to s3\n for each region supported and return all uploaded s3 url locations.\n\n When the key does not exist, the remaining work will be assigned to a celery background task\n with a url location returned immediately for obtaining task state updates.\n \"\"\"\n buckets = current_app.config['ARCHIVER_S3_BUCKETS']\n random_region = buckets.keys()[randint(0, len(buckets.keys()) - 1)]\n # use preferred region if available otherwise choose a valid one at random\n region = preferred_region if preferred_region and preferred_region in buckets else random_region\n bucket = buckets[region]\n s3 = current_app.aws.connect_to('s3', region)\n session = current_app.db.session('relengapi')\n\n # first, see if the key exists\n if not s3.get_bucket(bucket).get_key(key):\n task_id = key.replace('/', '_') # keep things simple and avoid slashes in task url\n # can't use unique support:\n # api.pub.build.mozilla.org/docs/development/databases/#unique-row-support-get-or-create\n # because we want to know when the row doesn't exist before creating it\n tracker = tables.ArchiverTask.query.filter(tables.ArchiverTask.task_id == task_id).first()\n if tracker and tracker.state in FINISHED_STATES:\n log.info('Task tracker: {} exists but finished with state: '\n '{}'.format(task_id, tracker.state))\n # remove tracker and try celery task again\n delete_tracker(tracker)\n tracker = None\n if not tracker:\n log.info(\"Creating new celery task and task tracker for: {}\".format(task_id))\n task = create_and_upload_archive.apply_async(args=[src_url, key], task_id=task_id)\n if task and task.id:\n pending_expires_at = now() + datetime.timedelta(seconds=PENDING_EXPIRES_IN)\n session.add(tables.ArchiverTask(task_id=task.id, s3_key=key, created_at=now(),\n pending_expires_at=pending_expires_at,\n src_url=src_url, state=\"PENDING\"))\n session.commit()\n else:\n return {}, 500\n return {}, 202, {'Location': url_for('archiver.task_status', task_id=task.id)}\n\n log.info(\"generating GET URL to {}, expires in {}s\".format(key, GET_EXPIRES_IN))\n # return 302 pointing to s3 url with archive\n signed_url = s3.generate_url(\n method='GET', expires_in=GET_EXPIRES_IN,\n bucket=bucket, key=key\n )\n return redirect(signed_url)"},"implementation":{"kind":"string","value":"@bp.route('/hgmo/<path:repo>/<rev>')\n@api.apimethod(None, unicode, unicode, unicode, unicode, unicode, status_code=302)\ndef get_hgmo_archive(repo, rev, subdir=None, suffix='tar.gz', preferred_region=None):\n \"\"\"\n An archiver for hg.mozilla.org related requests. Uses relengapi.blueprints.archiver.get_archive\n\n :param repo: the repo location off of hg.mozilla.org/\n :param rev: the rev associated with the repo\n :param subdir: optional subdir path to only archive a portion of the repo\n :param suffix: the archive extension type. defaulted to tar.gz\n :param preferred_region: the preferred s3 region to use\n \"\"\"\n # allow for the short hash and full hash to be passed\n rev = rev[0:12]\n src_url = current_app.config['ARCHIVER_HGMO_URL_TEMPLATE'].format(\n repo=repo, rev=rev, suffix=suffix, subdir=subdir or ''\n )\n # though slightly odd to append the archive suffix extension with a subdir, this:\n # 1) allows us to have archives based on different subdir locations from the same repo and rev\n # 2) is aligned with the hg.mozilla.org format\n key = '{repo}-{rev}.{suffix}'.format(repo=repo, rev=rev, suffix=suffix)\n if subdir:\n key += '/{}'.format(subdir)\n return get_archive(src_url, key, preferred_region)"},"start_line":{"kind":"number","value":124,"string":"124"},"end_line":{"kind":"number","value":147,"string":"147"},"file_content":{"kind":"string","value":"# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not distributed with this\n# file, You can obtain one at http://mozilla.org/MPL/2.0/.\n\nimport logging\n\n\nimport datetime\nimport sqlalchemy as sa\n\nfrom random import randint\n\nfrom flask import Blueprint\nfrom flask import current_app\nfrom flask import redirect\nfrom flask import url_for\n\nfrom relengapi.blueprints.archiver import tables\nfrom relengapi.blueprints.archiver.tasks import TASK_TIME_OUT\nfrom relengapi.blueprints.archiver.tasks import create_and_upload_archive\nfrom relengapi.blueprints.archiver.types import MozharnessArchiveTask\nfrom relengapi.lib import api\nfrom relengapi.lib import badpenny\nfrom relengapi.lib.time import now\n\nbp = Blueprint('archiver', __name__)\nlog = logging.getLogger(__name__)\n\nGET_EXPIRES_IN = 300\nPENDING_EXPIRES_IN = 60\nFINISHED_STATES = ['SUCCESS', 'FAILURE', 'REVOKED']\n\n\ndef delete_tracker(tracker):\n session = current_app.db.session('relengapi')\n log.info(\"deleting tracker with id: {}\".format(tracker.task_id))\n session.delete(tracker)\n session.commit()\n\n\ndef update_tracker_state(tracker, state):\n session = current_app.db.session('relengapi')\n log.info(\"updating tracker with id: {} to state: {}\".format(tracker.id, state))\n try:\n tracker.state = state\n session.commit()\n except sa.exc.IntegrityError:\n session.rollback()\n\n\n@badpenny.periodic_task(seconds=TASK_TIME_OUT)\ndef cleanup_old_tasks(job_status):\n \"\"\"delete any tracker task if it is older than the time a task can live for.\"\"\"\n session = current_app.db.session('relengapi')\n expiry_cutoff = now() - datetime.timedelta(seconds=TASK_TIME_OUT)\n table = tables.ArchiverTask\n for tracker in session.query(table).order_by(table.created_at):\n if tracker.created_at < expiry_cutoff:\n delete_tracker(tracker)\n else:\n break\n\n\ndef renew_tracker_pending_expiry(tracker):\n pending_expires_at = now() + datetime.timedelta(seconds=PENDING_EXPIRES_IN)\n session = current_app.db.session('relengapi')\n log.info(\"renewing tracker {} with pending expiry: {}\".format(tracker.id, pending_expires_at))\n tracker.pending_expires_at = pending_expires_at\n session.commit()\n\n\n@bp.route('/status/<task_id>')\n@api.apimethod(MozharnessArchiveTask, unicode)\ndef task_status(task_id):\n \"\"\"\n Check and return the current state of the create_and_upload_archive celery task with task id\n of <task_id>.\n\n If the task is unknown, state will be PENDING. Once the task starts it will be updated to\n STARTED and finally, if it completes, it will be either SUCCESS (no exceptions), or FAILURE.\n\n See update_state() within create_and_upload_archive and\n http://celery.readthedocs.org/en/latest/reference/celery.states.html for more details.\n\n If state is SUCCESS, it is safe to check response['s3_urls'] for the archives submitted to s3\n \"\"\"\n task = create_and_upload_archive.AsyncResult(task_id)\n task_tracker = tables.ArchiverTask.query.filter(tables.ArchiverTask.task_id == task_id).first()\n log.info(\"checking status of task id {}: current state {}\".format(task_id, task.state))\n task_info = task.info or {}\n response = {\n 'state': task.state,\n }\n if task.state != 'FAILURE':\n response['status'] = task_info.get('status', 'no status available at this point.')\n response['src_url'] = task_info.get('src_url', '')\n response['s3_urls'] = task_info.get('s3_urls', {})\n else:\n # something went wrong\n response['status'] = str(task.info) # this is the exception raised\n response['src_url'] = ''\n response['s3_urls'] = {}\n\n # archiver does not create any custom states, so we can assume to have only the defaults:\n # http://docs.celeryproject.org/en/latest/userguide/tasks.html#task-states\n # therefore, delete our state_id tracker from the db if the celery state is in a final state:\n # e.g. not RETRY, STARTED, or PENDING\n if task_tracker:\n if task.state in FINISHED_STATES:\n delete_tracker(task_tracker)\n elif task.state == \"PENDING\" and task_tracker.pending_expires_at < now():\n log.info(\"Task {} has expired from pending too long. Re-creating task\".format(task.id))\n renew_tracker_pending_expiry(task_tracker) # let exceptions bubble up before moving on\n create_and_upload_archive.apply_async(args=[task_tracker.src_url, task_tracker.s3_key],\n task_id=task.id)\n response['state'] = 'RETRY'\n response['status'] = 'Task has expired from pending for too long. Re-creating task.'\n elif task_tracker.state != task.state:\n update_tracker_state(task_tracker, task.state)\n\n return MozharnessArchiveTask(**response)\n\n\n@bp.route('/hgmo/<path:repo>/<rev>')\n@api.apimethod(None, unicode, unicode, unicode, unicode, unicode, status_code=302)\ndef get_hgmo_archive(repo, rev, subdir=None, suffix='tar.gz', preferred_region=None):\n \"\"\"\n An archiver for hg.mozilla.org related requests. Uses relengapi.blueprints.archiver.get_archive\n\n :param repo: the repo location off of hg.mozilla.org/\n :param rev: the rev associated with the repo\n :param subdir: optional subdir path to only archive a portion of the repo\n :param suffix: the archive extension type. defaulted to tar.gz\n :param preferred_region: the preferred s3 region to use\n \"\"\"\n # allow for the short hash and full hash to be passed\n rev = rev[0:12]\n src_url = current_app.config['ARCHIVER_HGMO_URL_TEMPLATE'].format(\n repo=repo, rev=rev, suffix=suffix, subdir=subdir or ''\n )\n # though slightly odd to append the archive suffix extension with a subdir, this:\n # 1) allows us to have archives based on different subdir locations from the same repo and rev\n # 2) is aligned with the hg.mozilla.org format\n key = '{repo}-{rev}.{suffix}'.format(repo=repo, rev=rev, suffix=suffix)\n if subdir:\n key += '/{}'.format(subdir)\n return get_archive(src_url, key, preferred_region)\n\n\ndef get_archive(src_url, key, preferred_region):\n \"\"\"\n A generic getter for retrieving an s3 location of an archive where the archive is based off a\n src_url.\n\n sub-dir: hg.mozilla.org supports archives of sub directories within a repository. This\n flexibility allows for creating archives of only a portion of what would normally be an entire\n repo archive.\n\n logic flow:\n If their is already a key within s3, a re-direct link is given for the\n s3 location. If the key does not exist, download the archive from src url, upload it to s3\n for each region supported and return all uploaded s3 url locations.\n\n When the key does not exist, the remaining work will be assigned to a celery background task\n with a url location returned immediately for obtaining task state updates.\n \"\"\"\n buckets = current_app.config['ARCHIVER_S3_BUCKETS']\n random_region = buckets.keys()[randint(0, len(buckets.keys()) - 1)]\n # use preferred region if available otherwise choose a valid one at random\n region = preferred_region if preferred_region and preferred_region in buckets else random_region\n bucket = buckets[region]\n s3 = current_app.aws.connect_to('s3', region)\n session = current_app.db.session('relengapi')\n\n # first, see if the key exists\n if not s3.get_bucket(bucket).get_key(key):\n task_id = key.replace('/', '_') # keep things simple and avoid slashes in task url\n # can't use unique support:\n # api.pub.build.mozilla.org/docs/development/databases/#unique-row-support-get-or-create\n # because we want to know when the row doesn't exist before creating it\n tracker = tables.ArchiverTask.query.filter(tables.ArchiverTask.task_id == task_id).first()\n if tracker and tracker.state in FINISHED_STATES:\n log.info('Task tracker: {} exists but finished with state: '\n '{}'.format(task_id, tracker.state))\n # remove tracker and try celery task again\n delete_tracker(tracker)\n tracker = None\n if not tracker:\n log.info(\"Creating new celery task and task tracker for: {}\".format(task_id))\n task = create_and_upload_archive.apply_async(args=[src_url, key], task_id=task_id)\n if task and task.id:\n pending_expires_at = now() + datetime.timedelta(seconds=PENDING_EXPIRES_IN)\n session.add(tables.ArchiverTask(task_id=task.id, s3_key=key, created_at=now(),\n pending_expires_at=pending_expires_at,\n src_url=src_url, state=\"PENDING\"))\n session.commit()\n else:\n return {}, 500\n return {}, 202, {'Location': url_for('archiver.task_status', task_id=task.id)}\n\n log.info(\"generating GET URL to {}, expires in {}s\".format(key, GET_EXPIRES_IN))\n # return 302 pointing to s3 url with archive\n signed_url = s3.generate_url(\n method='GET', expires_in=GET_EXPIRES_IN,\n bucket=bucket, key=key\n )\n return redirect(signed_url)\n"}}},{"rowIdx":2084,"cells":{"function_name":{"kind":"string","value":"is_absolute_uri"},"docstring":{"kind":"string","value":"Returns True if the parsed result is an \"absolute URI\".\n\nWe define an \"absolute URI\" as containing at mimimum a **scheme** and an\n**host** (a.k.a., an authority).\n\nIt must contain SH according to the nomenclature defined in this proposal:\nhttps://gist.github.com/andrewdotn/eebeaa60d48c3c0f6f9fc75f0ede8d03#proposal\n\nExamples of absolute URIs:\n [SH ] https://example.com\n [SHP ] https://example.com/\n [SHPF] https://example.com/foo/cat.gif\n\nWhat are NOT absolute URIs:\n [ F] cat.gif\n [ P ] /\n [ PF] /foo/cat.gif\n [ HPF] //example.com/foo/cat.gif†\n [S F] https:cat.gif (uncommon)\n [S PF] https:/foo/cat.gif (uncommon)\n\n†: This is called a \"network-path reference, and relies on inferring the scheme\n based on an existing base URI. For our purposes, this is not \"absolute\" enough!\n Source: https://tools.ietf.org/html/rfc3986#section-4.2"},"masked_code":{"kind":"string","value":"\"\"\"\nGet absolute URLs for static assets.\n\"\"\"\n\nfrom urllib.parse import ParseResult, urlparse, urlunparse\n\nfrom django import template\nfrom django.templatetags.static import StaticNode\nfrom django.urls import reverse\n\nregister = template.Library()\n\n\nclass AbstaticNode(StaticNode):\n \"\"\"\n {% abstatic %} is like Django's {% static %} tag,\n but always returns an absolute URI.\n \"\"\"\n\n def url(self, context) -> str:\n url_to_asset = super().url(context)\n\n parsed_url = urlparse(url_to_asset)\n assert parsed_url.path\n\n if is_absolute_uri(parsed_url):\n return url_to_asset\n\n # Delegate to Django to provide its own schema and authority:\n path_and_file = to_pf_url(parsed_url)\n return context[\"request\"].build_absolute_uri(path_and_file)\n\n\n# MASKED: is_absolute_uri function (lines 34-65)\n\n\ndef to_pf_url(url: ParseResult):\n \"\"\"\n Returns *P*ath and *F*ile as defined here:\n https://gist.github.com/andrewdotn/eebeaa60d48c3c0f6f9fc75f0ede8d03#proposal\n \"\"\"\n return urlunparse(url._replace(scheme=\"\", netloc=\"\"))\n\n\n@register.tag\ndef abstatic(parser, token):\n \"\"\"\n Given a relative path to a static asset, return the absolute path to the\n asset.\n\n Derived from: https://github.com/django/django/blob/635d53a86a36cde7866b9caefeb64d809e6bfcd9/django/templatetags/static.py#L143-L159\n \"\"\"\n return AbstaticNode.handle_token(parser, token)"},"implementation":{"kind":"string","value":"def is_absolute_uri(url: ParseResult) -> bool:\n \"\"\"\n Returns True if the parsed result is an \"absolute URI\".\n\n We define an \"absolute URI\" as containing at mimimum a **scheme** and an\n **host** (a.k.a., an authority).\n\n It must contain SH according to the nomenclature defined in this proposal:\n https://gist.github.com/andrewdotn/eebeaa60d48c3c0f6f9fc75f0ede8d03#proposal\n\n Examples of absolute URIs:\n [SH ] https://example.com\n [SHP ] https://example.com/\n [SHPF] https://example.com/foo/cat.gif\n\n What are NOT absolute URIs:\n [ F] cat.gif\n [ P ] /\n [ PF] /foo/cat.gif\n [ HPF] //example.com/foo/cat.gif†\n [S F] https:cat.gif (uncommon)\n [S PF] https:/foo/cat.gif (uncommon)\n\n †: This is called a \"network-path reference, and relies on inferring the scheme\n based on an existing base URI. For our purposes, this is not \"absolute\" enough!\n Source: https://tools.ietf.org/html/rfc3986#section-4.2\n\n \"\"\"\n # netloc == authority, i.e., [username[:password]@]example.com[:443]\n if url.scheme and url.netloc:\n return True\n return False"},"start_line":{"kind":"number","value":34,"string":"34"},"end_line":{"kind":"number","value":65,"string":"65"},"file_content":{"kind":"string","value":"\"\"\"\nGet absolute URLs for static assets.\n\"\"\"\n\nfrom urllib.parse import ParseResult, urlparse, urlunparse\n\nfrom django import template\nfrom django.templatetags.static import StaticNode\nfrom django.urls import reverse\n\nregister = template.Library()\n\n\nclass AbstaticNode(StaticNode):\n \"\"\"\n {% abstatic %} is like Django's {% static %} tag,\n but always returns an absolute URI.\n \"\"\"\n\n def url(self, context) -> str:\n url_to_asset = super().url(context)\n\n parsed_url = urlparse(url_to_asset)\n assert parsed_url.path\n\n if is_absolute_uri(parsed_url):\n return url_to_asset\n\n # Delegate to Django to provide its own schema and authority:\n path_and_file = to_pf_url(parsed_url)\n return context[\"request\"].build_absolute_uri(path_and_file)\n\n\ndef is_absolute_uri(url: ParseResult) -> bool:\n \"\"\"\n Returns True if the parsed result is an \"absolute URI\".\n\n We define an \"absolute URI\" as containing at mimimum a **scheme** and an\n **host** (a.k.a., an authority).\n\n It must contain SH according to the nomenclature defined in this proposal:\n https://gist.github.com/andrewdotn/eebeaa60d48c3c0f6f9fc75f0ede8d03#proposal\n\n Examples of absolute URIs:\n [SH ] https://example.com\n [SHP ] https://example.com/\n [SHPF] https://example.com/foo/cat.gif\n\n What are NOT absolute URIs:\n [ F] cat.gif\n [ P ] /\n [ PF] /foo/cat.gif\n [ HPF] //example.com/foo/cat.gif†\n [S F] https:cat.gif (uncommon)\n [S PF] https:/foo/cat.gif (uncommon)\n\n †: This is called a \"network-path reference, and relies on inferring the scheme\n based on an existing base URI. For our purposes, this is not \"absolute\" enough!\n Source: https://tools.ietf.org/html/rfc3986#section-4.2\n\n \"\"\"\n # netloc == authority, i.e., [username[:password]@]example.com[:443]\n if url.scheme and url.netloc:\n return True\n return False\n\n\ndef to_pf_url(url: ParseResult):\n \"\"\"\n Returns *P*ath and *F*ile as defined here:\n https://gist.github.com/andrewdotn/eebeaa60d48c3c0f6f9fc75f0ede8d03#proposal\n \"\"\"\n return urlunparse(url._replace(scheme=\"\", netloc=\"\"))\n\n\n@register.tag\ndef abstatic(parser, token):\n \"\"\"\n Given a relative path to a static asset, return the absolute path to the\n asset.\n\n Derived from: https://github.com/django/django/blob/635d53a86a36cde7866b9caefeb64d809e6bfcd9/django/templatetags/static.py#L143-L159\n \"\"\"\n return AbstaticNode.handle_token(parser, token)\n"}}},{"rowIdx":2085,"cells":{"function_name":{"kind":"string","value":"test_can_add_gates_into_free_space"},"docstring":{"kind":"string","value":"The scheduler does some time bookkeeping to know when qubits are free to be\nscheduled. Make sure this works for qubits that are used in the future. This was\na bug, uncovered by this example:\n\n q0 = - - - - |X|\n q1 = |X| |u2| |X|\n\nIn ALAP scheduling, the next operation on qubit 0 would be added at t=0 rather\nthan immediately before the X gate."},"masked_code":{"kind":"string","value":"# -*- coding: utf-8 -*-\n\n# This code is part of Qiskit.\n#\n# (C) Copyright IBM 2019.\n#\n# This code is licensed under the Apache License, Version 2.0. You may\n# obtain a copy of this license in the LICENSE.txt file in the root directory\n# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.\n#\n# Any modifications or derivative works of this code must retain this\n# copyright notice, and modified files need to carry a notice indicating\n# that they have been altered from the originals.\n\n\"\"\"Test cases for the pulse scheduler passes.\"\"\"\n\nfrom qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, schedule\nfrom qiskit.pulse import (Schedule, DriveChannel, AcquireChannel, Acquire,\n MeasureChannel, MemorySlot)\n\nfrom qiskit.test.mock import FakeOpenPulse2Q, FakeOpenPulse3Q\nfrom qiskit.test import QiskitTestCase\n\n\nclass TestBasicSchedule(QiskitTestCase):\n \"\"\"Scheduling tests.\"\"\"\n\n def setUp(self):\n self.backend = FakeOpenPulse2Q()\n self.cmd_def = self.backend.defaults().build_cmd_def()\n\n def test_alap_pass(self):\n \"\"\"Test ALAP scheduling.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.u2(3.14, 1.57, q[0])\n qc.u2(0.5, 0.25, q[1])\n qc.barrier(q[1])\n qc.u2(0.5, 0.25, q[1])\n qc.barrier(q[0], q[1])\n qc.cx(q[0], q[1])\n qc.measure(q, c)\n sched = schedule(qc, self.backend)\n # X pulse on q0 should end at the start of the CNOT\n expected = Schedule(\n (28, self.cmd_def.get('u2', [0], 3.14, 1.57)),\n self.cmd_def.get('u2', [1], 0.5, 0.25),\n (28, self.cmd_def.get('u2', [1], 0.5, 0.25)),\n (56, self.cmd_def.get('cx', [0, 1])),\n (78, self.cmd_def.get('measure', [0, 1])))\n for actual, expected in zip(sched.instructions, expected.instructions):\n self.assertEqual(actual[0], expected[0])\n self.assertEqual(actual[1].command, expected[1].command)\n self.assertEqual(actual[1].channels, expected[1].channels)\n\n def test_alap_with_barriers(self):\n \"\"\"Test that ALAP respects barriers on new qubits.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.u2(0, 0, q[0])\n qc.barrier(q[0], q[1])\n qc.u2(0, 0, q[1])\n sched = schedule(qc, self.backend, method='alap')\n expected = Schedule(\n self.cmd_def.get('u2', [0], 0, 0),\n (28, self.cmd_def.get('u2', [1], 0, 0)))\n for actual, expected in zip(sched.instructions, expected.instructions):\n self.assertEqual(actual[0], expected[0])\n self.assertEqual(actual[1].command, expected[1].command)\n self.assertEqual(actual[1].channels, expected[1].channels)\n\n def test_alap_aligns_end(self):\n \"\"\"Test that ALAP always acts as though there is a final global barrier.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.u3(0, 0, 0, q[0])\n qc.u2(0, 0, q[1])\n sched = schedule(qc, self.backend, method='alap')\n expected_sched = Schedule(\n self.cmd_def.get('u2', [1], 0, 0),\n (26, self.cmd_def.get('u3', [0], 0, 0, 0)))\n for actual, expected in zip(sched.instructions, expected_sched.instructions):\n self.assertEqual(actual[0], expected[0])\n self.assertEqual(actual[1].command, expected[1].command)\n self.assertEqual(actual[1].channels, expected[1].channels)\n self.assertEqual(sched.ch_duration(DriveChannel(0)),\n expected_sched.ch_duration(DriveChannel(1)))\n\n def test_asap_pass(self):\n \"\"\"Test ASAP scheduling.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.u2(3.14, 1.57, q[0])\n qc.u2(0.5, 0.25, q[1])\n qc.barrier(q[1])\n qc.u2(0.5, 0.25, q[1])\n qc.barrier(q[0], q[1])\n qc.cx(q[0], q[1])\n qc.measure(q, c)\n sched = schedule(qc, self.backend, method=\"as_soon_as_possible\")\n # X pulse on q0 should start at t=0\n expected = Schedule(\n self.cmd_def.get('u2', [0], 3.14, 1.57),\n self.cmd_def.get('u2', [1], 0.5, 0.25),\n (28, self.cmd_def.get('u2', [1], 0.5, 0.25)),\n (56, self.cmd_def.get('cx', [0, 1])),\n (78, self.cmd_def.get('measure', [0, 1])))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_alap_resource_respecting(self):\n \"\"\"Test that the ALAP pass properly respects busy resources when backwards scheduling.\n For instance, a CX on 0 and 1 followed by an X on only 1 must respect both qubits'\n timeline.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.cx(q[0], q[1])\n qc.u2(0.5, 0.25, q[1])\n sched = schedule(qc, self.backend, method=\"as_late_as_possible\")\n insts = sched.instructions\n self.assertEqual(insts[0][0], 0)\n self.assertEqual(insts[4][0], 22)\n\n qc = QuantumCircuit(q, c)\n qc.cx(q[0], q[1])\n qc.u2(0.5, 0.25, q[1])\n qc.measure(q, c)\n sched = schedule(qc, self.backend, method=\"as_late_as_possible\")\n self.assertEqual(sched.instructions[-1][0], 50)\n\n def test_cmd_def_schedules_unaltered(self):\n \"\"\"Test that forward scheduling doesn't change relative timing with a command.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.cx(q[0], q[1])\n sched1 = schedule(qc, self.backend, method=\"as_soon_as_possible\")\n sched2 = schedule(qc, self.backend, method=\"as_late_as_possible\")\n self.assertEqual(sched1.instructions, sched2.instructions)\n insts = sched1.instructions\n self.assertEqual(insts[0][0], 0)\n self.assertEqual(insts[1][0], 10)\n self.assertEqual(insts[2][0], 20)\n self.assertEqual(insts[3][0], 20)\n\n def test_measure_combined(self):\n \"\"\"\n Test to check for measure on the same qubit which generated another measure schedule.\n\n The measures on different qubits are combined, but measures on the same qubit\n adds another measure to the schedule.\n \"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.u2(3.14, 1.57, q[0])\n qc.cx(q[0], q[1])\n qc.measure(q[0], c[0])\n qc.measure(q[1], c[1])\n qc.measure(q[1], c[1])\n sched = schedule(qc, self.backend, method=\"as_soon_as_possible\")\n expected = Schedule(\n self.cmd_def.get('u2', [0], 3.14, 1.57),\n (28, self.cmd_def.get('cx', [0, 1])),\n (50, self.cmd_def.get('measure', [0, 1])),\n (60, self.cmd_def.get('measure', [0, 1]).filter(channels=[MeasureChannel(1)])),\n (60, Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1)],\n [MemorySlot(0), MemorySlot(1)])))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_3q_schedule(self):\n \"\"\"Test a schedule that was recommended by David McKay :D \"\"\"\n backend = FakeOpenPulse3Q()\n cmd_def = backend.defaults().build_cmd_def()\n q = QuantumRegister(3)\n c = ClassicalRegister(3)\n qc = QuantumCircuit(q, c)\n qc.cx(q[0], q[1])\n qc.u2(0.778, 0.122, q[2])\n qc.u3(3.14, 1.57, 0., q[0])\n qc.u2(3.14, 1.57, q[1])\n qc.cx(q[1], q[2])\n qc.u2(0.778, 0.122, q[2])\n sched = schedule(qc, backend)\n expected = Schedule(\n cmd_def.get('cx', [0, 1]),\n (22, cmd_def.get('u2', [1], 3.14, 1.57)),\n (46, cmd_def.get('u2', [2], 0.778, 0.122)),\n (50, cmd_def.get('cx', [1, 2])),\n (72, cmd_def.get('u2', [2], 0.778, 0.122)),\n (74, cmd_def.get('u3', [0], 3.14, 1.57)))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_schedule_multi(self):\n \"\"\"Test scheduling multiple circuits at once.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc0 = QuantumCircuit(q, c)\n qc0.cx(q[0], q[1])\n qc1 = QuantumCircuit(q, c)\n qc1.cx(q[0], q[1])\n schedules = schedule([qc0, qc1], self.backend)\n expected_insts = schedule(qc0, self.backend).instructions\n self.assertEqual(schedules[0].instructions, expected_insts)\n\n def test_circuit_name_kept(self):\n \"\"\"Test that the new schedule gets its name from the circuit.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c, name='CIRCNAME')\n qc.cx(q[0], q[1])\n sched = schedule(qc, self.backend, method=\"asap\")\n self.assertEqual(sched.name, qc.name)\n sched = schedule(qc, self.backend, method=\"alap\")\n self.assertEqual(sched.name, qc.name)\n\n# MASKED: test_can_add_gates_into_free_space function (lines 221-246)\n\n def test_barriers_in_middle(self):\n \"\"\"As a follow on to `test_can_add_gates_into_free_space`, similar issues\n arose for barriers, specifically.\n \"\"\"\n qr = QuantumRegister(2)\n qc = QuantumCircuit(qr)\n for i in range(2):\n qc.u2(0, 0, [qr[i]])\n qc.barrier(qr[i])\n qc.u1(3.14, [qr[i]])\n qc.barrier(qr[i])\n qc.u2(0, 0, [qr[i]])\n sched = schedule(qc, self.backend, method=\"alap\")\n expected = Schedule(\n self.cmd_def.get('u2', [0], 0, 0),\n self.cmd_def.get('u2', [1], 0, 0),\n (28, self.cmd_def.get('u1', [0], 3.14)),\n (28, self.cmd_def.get('u1', [1], 3.14)),\n (28, self.cmd_def.get('u2', [0], 0, 0)),\n (28, self.cmd_def.get('u2', [1], 0, 0)))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_only_needed_measures(self):\n \"\"\"Test that `MeasureChannel`s are only added for measured qubits.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.measure(q[1], c[1])\n sched_all_channels = schedule(qc, self.backend, method=\"as_soon_as_possible\").channels\n deleted_channels = [MeasureChannel(0)]\n self.assertNotIn(sched_all_channels, deleted_channels)\n\n def test_user_mapping_for_memslots(self):\n \"\"\"\n Test that the new schedule only has required `MeasureChannel`s and that the\n `MemorySlot`s are mapped according to the input circuit.\n \"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.measure(q[0], c[1])\n sched = schedule(qc, self.backend)\n expected = Schedule(\n self.cmd_def.get('measure', [0, 1]).filter(channels=[MeasureChannel(0)]),\n Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1)],\n [MemorySlot(1), MemorySlot(0)]))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_user_mapping_for_memslots_3Q(self):\n \"\"\"Test measuring two of three qubits.\"\"\"\n backend = FakeOpenPulse3Q()\n cmd_def = backend.defaults().build_cmd_def()\n q = QuantumRegister(3)\n c = ClassicalRegister(3)\n qc = QuantumCircuit(q, c)\n qc.measure(q[1], c[2])\n qc.measure(q[2], c[0])\n sched = schedule(qc, backend)\n expected = Schedule(\n cmd_def.get('measure', [0, 1, 2]).filter(\n channels=[MeasureChannel(1), MeasureChannel(2)]),\n Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1), AcquireChannel(2)],\n [MemorySlot(1), MemorySlot(2), MemorySlot(0)]))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_multiple_measure_in_3Q(self):\n \"\"\"Test multiple measure, user memslot mapping, 3Q.\"\"\"\n backend = FakeOpenPulse3Q()\n cmd_def = backend.defaults().build_cmd_def()\n q = QuantumRegister(3)\n c = ClassicalRegister(5)\n qc = QuantumCircuit(q, c)\n qc.measure(q[0], c[2])\n qc.measure(q[0], c[4])\n sched = schedule(qc, backend)\n expected = Schedule(\n cmd_def.get('measure', [0, 1, 2]).filter(channels=[MeasureChannel(0)]),\n Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1), AcquireChannel(2)],\n [MemorySlot(2), MemorySlot(0), MemorySlot(1)]),\n (10, cmd_def.get('measure', [0, 1, 2]).filter(channels=[MeasureChannel(0)])),\n (10, Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1), AcquireChannel(2)],\n [MemorySlot(4), MemorySlot(0), MemorySlot(1)])))\n self.assertEqual(sched.instructions, expected.instructions)"},"implementation":{"kind":"string","value":" def test_can_add_gates_into_free_space(self):\n \"\"\"The scheduler does some time bookkeeping to know when qubits are free to be\n scheduled. Make sure this works for qubits that are used in the future. This was\n a bug, uncovered by this example:\n\n q0 = - - - - |X|\n q1 = |X| |u2| |X|\n\n In ALAP scheduling, the next operation on qubit 0 would be added at t=0 rather\n than immediately before the X gate.\n \"\"\"\n qr = QuantumRegister(2)\n qc = QuantumCircuit(qr)\n for i in range(2):\n qc.u2(0, 0, [qr[i]])\n qc.u1(3.14, [qr[i]])\n qc.u2(0, 0, [qr[i]])\n sched = schedule(qc, self.backend, method=\"alap\")\n expected = Schedule(\n self.cmd_def.get('u2', [0], 0, 0),\n self.cmd_def.get('u2', [1], 0, 0),\n (28, self.cmd_def.get('u1', [0], 3.14)),\n (28, self.cmd_def.get('u1', [1], 3.14)),\n (28, self.cmd_def.get('u2', [0], 0, 0)),\n (28, self.cmd_def.get('u2', [1], 0, 0)))\n self.assertEqual(sched.instructions, expected.instructions)"},"start_line":{"kind":"number","value":221,"string":"221"},"end_line":{"kind":"number","value":246,"string":"246"},"file_content":{"kind":"string","value":"# -*- coding: utf-8 -*-\n\n# This code is part of Qiskit.\n#\n# (C) Copyright IBM 2019.\n#\n# This code is licensed under the Apache License, Version 2.0. You may\n# obtain a copy of this license in the LICENSE.txt file in the root directory\n# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.\n#\n# Any modifications or derivative works of this code must retain this\n# copyright notice, and modified files need to carry a notice indicating\n# that they have been altered from the originals.\n\n\"\"\"Test cases for the pulse scheduler passes.\"\"\"\n\nfrom qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, schedule\nfrom qiskit.pulse import (Schedule, DriveChannel, AcquireChannel, Acquire,\n MeasureChannel, MemorySlot)\n\nfrom qiskit.test.mock import FakeOpenPulse2Q, FakeOpenPulse3Q\nfrom qiskit.test import QiskitTestCase\n\n\nclass TestBasicSchedule(QiskitTestCase):\n \"\"\"Scheduling tests.\"\"\"\n\n def setUp(self):\n self.backend = FakeOpenPulse2Q()\n self.cmd_def = self.backend.defaults().build_cmd_def()\n\n def test_alap_pass(self):\n \"\"\"Test ALAP scheduling.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.u2(3.14, 1.57, q[0])\n qc.u2(0.5, 0.25, q[1])\n qc.barrier(q[1])\n qc.u2(0.5, 0.25, q[1])\n qc.barrier(q[0], q[1])\n qc.cx(q[0], q[1])\n qc.measure(q, c)\n sched = schedule(qc, self.backend)\n # X pulse on q0 should end at the start of the CNOT\n expected = Schedule(\n (28, self.cmd_def.get('u2', [0], 3.14, 1.57)),\n self.cmd_def.get('u2', [1], 0.5, 0.25),\n (28, self.cmd_def.get('u2', [1], 0.5, 0.25)),\n (56, self.cmd_def.get('cx', [0, 1])),\n (78, self.cmd_def.get('measure', [0, 1])))\n for actual, expected in zip(sched.instructions, expected.instructions):\n self.assertEqual(actual[0], expected[0])\n self.assertEqual(actual[1].command, expected[1].command)\n self.assertEqual(actual[1].channels, expected[1].channels)\n\n def test_alap_with_barriers(self):\n \"\"\"Test that ALAP respects barriers on new qubits.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.u2(0, 0, q[0])\n qc.barrier(q[0], q[1])\n qc.u2(0, 0, q[1])\n sched = schedule(qc, self.backend, method='alap')\n expected = Schedule(\n self.cmd_def.get('u2', [0], 0, 0),\n (28, self.cmd_def.get('u2', [1], 0, 0)))\n for actual, expected in zip(sched.instructions, expected.instructions):\n self.assertEqual(actual[0], expected[0])\n self.assertEqual(actual[1].command, expected[1].command)\n self.assertEqual(actual[1].channels, expected[1].channels)\n\n def test_alap_aligns_end(self):\n \"\"\"Test that ALAP always acts as though there is a final global barrier.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.u3(0, 0, 0, q[0])\n qc.u2(0, 0, q[1])\n sched = schedule(qc, self.backend, method='alap')\n expected_sched = Schedule(\n self.cmd_def.get('u2', [1], 0, 0),\n (26, self.cmd_def.get('u3', [0], 0, 0, 0)))\n for actual, expected in zip(sched.instructions, expected_sched.instructions):\n self.assertEqual(actual[0], expected[0])\n self.assertEqual(actual[1].command, expected[1].command)\n self.assertEqual(actual[1].channels, expected[1].channels)\n self.assertEqual(sched.ch_duration(DriveChannel(0)),\n expected_sched.ch_duration(DriveChannel(1)))\n\n def test_asap_pass(self):\n \"\"\"Test ASAP scheduling.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.u2(3.14, 1.57, q[0])\n qc.u2(0.5, 0.25, q[1])\n qc.barrier(q[1])\n qc.u2(0.5, 0.25, q[1])\n qc.barrier(q[0], q[1])\n qc.cx(q[0], q[1])\n qc.measure(q, c)\n sched = schedule(qc, self.backend, method=\"as_soon_as_possible\")\n # X pulse on q0 should start at t=0\n expected = Schedule(\n self.cmd_def.get('u2', [0], 3.14, 1.57),\n self.cmd_def.get('u2', [1], 0.5, 0.25),\n (28, self.cmd_def.get('u2', [1], 0.5, 0.25)),\n (56, self.cmd_def.get('cx', [0, 1])),\n (78, self.cmd_def.get('measure', [0, 1])))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_alap_resource_respecting(self):\n \"\"\"Test that the ALAP pass properly respects busy resources when backwards scheduling.\n For instance, a CX on 0 and 1 followed by an X on only 1 must respect both qubits'\n timeline.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.cx(q[0], q[1])\n qc.u2(0.5, 0.25, q[1])\n sched = schedule(qc, self.backend, method=\"as_late_as_possible\")\n insts = sched.instructions\n self.assertEqual(insts[0][0], 0)\n self.assertEqual(insts[4][0], 22)\n\n qc = QuantumCircuit(q, c)\n qc.cx(q[0], q[1])\n qc.u2(0.5, 0.25, q[1])\n qc.measure(q, c)\n sched = schedule(qc, self.backend, method=\"as_late_as_possible\")\n self.assertEqual(sched.instructions[-1][0], 50)\n\n def test_cmd_def_schedules_unaltered(self):\n \"\"\"Test that forward scheduling doesn't change relative timing with a command.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.cx(q[0], q[1])\n sched1 = schedule(qc, self.backend, method=\"as_soon_as_possible\")\n sched2 = schedule(qc, self.backend, method=\"as_late_as_possible\")\n self.assertEqual(sched1.instructions, sched2.instructions)\n insts = sched1.instructions\n self.assertEqual(insts[0][0], 0)\n self.assertEqual(insts[1][0], 10)\n self.assertEqual(insts[2][0], 20)\n self.assertEqual(insts[3][0], 20)\n\n def test_measure_combined(self):\n \"\"\"\n Test to check for measure on the same qubit which generated another measure schedule.\n\n The measures on different qubits are combined, but measures on the same qubit\n adds another measure to the schedule.\n \"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.u2(3.14, 1.57, q[0])\n qc.cx(q[0], q[1])\n qc.measure(q[0], c[0])\n qc.measure(q[1], c[1])\n qc.measure(q[1], c[1])\n sched = schedule(qc, self.backend, method=\"as_soon_as_possible\")\n expected = Schedule(\n self.cmd_def.get('u2', [0], 3.14, 1.57),\n (28, self.cmd_def.get('cx', [0, 1])),\n (50, self.cmd_def.get('measure', [0, 1])),\n (60, self.cmd_def.get('measure', [0, 1]).filter(channels=[MeasureChannel(1)])),\n (60, Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1)],\n [MemorySlot(0), MemorySlot(1)])))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_3q_schedule(self):\n \"\"\"Test a schedule that was recommended by David McKay :D \"\"\"\n backend = FakeOpenPulse3Q()\n cmd_def = backend.defaults().build_cmd_def()\n q = QuantumRegister(3)\n c = ClassicalRegister(3)\n qc = QuantumCircuit(q, c)\n qc.cx(q[0], q[1])\n qc.u2(0.778, 0.122, q[2])\n qc.u3(3.14, 1.57, 0., q[0])\n qc.u2(3.14, 1.57, q[1])\n qc.cx(q[1], q[2])\n qc.u2(0.778, 0.122, q[2])\n sched = schedule(qc, backend)\n expected = Schedule(\n cmd_def.get('cx', [0, 1]),\n (22, cmd_def.get('u2', [1], 3.14, 1.57)),\n (46, cmd_def.get('u2', [2], 0.778, 0.122)),\n (50, cmd_def.get('cx', [1, 2])),\n (72, cmd_def.get('u2', [2], 0.778, 0.122)),\n (74, cmd_def.get('u3', [0], 3.14, 1.57)))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_schedule_multi(self):\n \"\"\"Test scheduling multiple circuits at once.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc0 = QuantumCircuit(q, c)\n qc0.cx(q[0], q[1])\n qc1 = QuantumCircuit(q, c)\n qc1.cx(q[0], q[1])\n schedules = schedule([qc0, qc1], self.backend)\n expected_insts = schedule(qc0, self.backend).instructions\n self.assertEqual(schedules[0].instructions, expected_insts)\n\n def test_circuit_name_kept(self):\n \"\"\"Test that the new schedule gets its name from the circuit.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c, name='CIRCNAME')\n qc.cx(q[0], q[1])\n sched = schedule(qc, self.backend, method=\"asap\")\n self.assertEqual(sched.name, qc.name)\n sched = schedule(qc, self.backend, method=\"alap\")\n self.assertEqual(sched.name, qc.name)\n\n def test_can_add_gates_into_free_space(self):\n \"\"\"The scheduler does some time bookkeeping to know when qubits are free to be\n scheduled. Make sure this works for qubits that are used in the future. This was\n a bug, uncovered by this example:\n\n q0 = - - - - |X|\n q1 = |X| |u2| |X|\n\n In ALAP scheduling, the next operation on qubit 0 would be added at t=0 rather\n than immediately before the X gate.\n \"\"\"\n qr = QuantumRegister(2)\n qc = QuantumCircuit(qr)\n for i in range(2):\n qc.u2(0, 0, [qr[i]])\n qc.u1(3.14, [qr[i]])\n qc.u2(0, 0, [qr[i]])\n sched = schedule(qc, self.backend, method=\"alap\")\n expected = Schedule(\n self.cmd_def.get('u2', [0], 0, 0),\n self.cmd_def.get('u2', [1], 0, 0),\n (28, self.cmd_def.get('u1', [0], 3.14)),\n (28, self.cmd_def.get('u1', [1], 3.14)),\n (28, self.cmd_def.get('u2', [0], 0, 0)),\n (28, self.cmd_def.get('u2', [1], 0, 0)))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_barriers_in_middle(self):\n \"\"\"As a follow on to `test_can_add_gates_into_free_space`, similar issues\n arose for barriers, specifically.\n \"\"\"\n qr = QuantumRegister(2)\n qc = QuantumCircuit(qr)\n for i in range(2):\n qc.u2(0, 0, [qr[i]])\n qc.barrier(qr[i])\n qc.u1(3.14, [qr[i]])\n qc.barrier(qr[i])\n qc.u2(0, 0, [qr[i]])\n sched = schedule(qc, self.backend, method=\"alap\")\n expected = Schedule(\n self.cmd_def.get('u2', [0], 0, 0),\n self.cmd_def.get('u2', [1], 0, 0),\n (28, self.cmd_def.get('u1', [0], 3.14)),\n (28, self.cmd_def.get('u1', [1], 3.14)),\n (28, self.cmd_def.get('u2', [0], 0, 0)),\n (28, self.cmd_def.get('u2', [1], 0, 0)))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_only_needed_measures(self):\n \"\"\"Test that `MeasureChannel`s are only added for measured qubits.\"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.measure(q[1], c[1])\n sched_all_channels = schedule(qc, self.backend, method=\"as_soon_as_possible\").channels\n deleted_channels = [MeasureChannel(0)]\n self.assertNotIn(sched_all_channels, deleted_channels)\n\n def test_user_mapping_for_memslots(self):\n \"\"\"\n Test that the new schedule only has required `MeasureChannel`s and that the\n `MemorySlot`s are mapped according to the input circuit.\n \"\"\"\n q = QuantumRegister(2)\n c = ClassicalRegister(2)\n qc = QuantumCircuit(q, c)\n qc.measure(q[0], c[1])\n sched = schedule(qc, self.backend)\n expected = Schedule(\n self.cmd_def.get('measure', [0, 1]).filter(channels=[MeasureChannel(0)]),\n Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1)],\n [MemorySlot(1), MemorySlot(0)]))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_user_mapping_for_memslots_3Q(self):\n \"\"\"Test measuring two of three qubits.\"\"\"\n backend = FakeOpenPulse3Q()\n cmd_def = backend.defaults().build_cmd_def()\n q = QuantumRegister(3)\n c = ClassicalRegister(3)\n qc = QuantumCircuit(q, c)\n qc.measure(q[1], c[2])\n qc.measure(q[2], c[0])\n sched = schedule(qc, backend)\n expected = Schedule(\n cmd_def.get('measure', [0, 1, 2]).filter(\n channels=[MeasureChannel(1), MeasureChannel(2)]),\n Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1), AcquireChannel(2)],\n [MemorySlot(1), MemorySlot(2), MemorySlot(0)]))\n self.assertEqual(sched.instructions, expected.instructions)\n\n def test_multiple_measure_in_3Q(self):\n \"\"\"Test multiple measure, user memslot mapping, 3Q.\"\"\"\n backend = FakeOpenPulse3Q()\n cmd_def = backend.defaults().build_cmd_def()\n q = QuantumRegister(3)\n c = ClassicalRegister(5)\n qc = QuantumCircuit(q, c)\n qc.measure(q[0], c[2])\n qc.measure(q[0], c[4])\n sched = schedule(qc, backend)\n expected = Schedule(\n cmd_def.get('measure', [0, 1, 2]).filter(channels=[MeasureChannel(0)]),\n Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1), AcquireChannel(2)],\n [MemorySlot(2), MemorySlot(0), MemorySlot(1)]),\n (10, cmd_def.get('measure', [0, 1, 2]).filter(channels=[MeasureChannel(0)])),\n (10, Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1), AcquireChannel(2)],\n [MemorySlot(4), MemorySlot(0), MemorySlot(1)])))\n self.assertEqual(sched.instructions, expected.instructions)\n"}}},{"rowIdx":2086,"cells":{"function_name":{"kind":"string","value":"default_data_collator"},"docstring":{"kind":"string","value":"Very simple data collator that simply collates batches of dict-like objects and performs special handling for\npotential keys named:\n\n - ``label``: handles a single value (int or float) per object\n - ``label_ids``: handles a list of values per object\n\nDoes not do any additional preprocessing: property names of the input object will be used as corresponding inputs\nto the model. See glue and ner for example of how it's useful."},"masked_code":{"kind":"string","value":"# Copyright 2020 The HuggingFace Team. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport random\nimport warnings\nfrom dataclasses import dataclass\nfrom typing import Any, Callable, Dict, List, NewType, Optional, Tuple, Union\n\nimport torch\nfrom torch.nn.utils.rnn import pad_sequence\n\nfrom ..file_utils import PaddingStrategy\nfrom ..modeling_utils import PreTrainedModel\nfrom ..models.bert import BertTokenizer, BertTokenizerFast\nfrom ..tokenization_utils_base import BatchEncoding, PreTrainedTokenizerBase\n\n\nInputDataClass = NewType(\"InputDataClass\", Any)\n\n\"\"\"\nA DataCollator is a function that takes a list of samples from a Dataset and collate them into a batch, as a dictionary\nof Tensors.\n\"\"\"\nDataCollator = NewType(\"DataCollator\", Callable[[List[InputDataClass]], Dict[str, torch.Tensor]])\n\n\n# MASKED: default_data_collator function (lines 38-83)\n\n\n@dataclass\nclass DataCollatorWithPadding:\n \"\"\"\n Data collator that will dynamically pad the inputs received.\n\n Args:\n tokenizer (:class:`~transformers.PreTrainedTokenizer` or :class:`~transformers.PreTrainedTokenizerFast`):\n The tokenizer used for encoding the data.\n padding (:obj:`bool`, :obj:`str` or :class:`~transformers.file_utils.PaddingStrategy`, `optional`, defaults to :obj:`True`):\n Select a strategy to pad the returned sequences (according to the model's padding side and padding index)\n among:\n\n * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single\n sequence if provided).\n * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the\n maximum acceptable input length for the model if that argument is not provided.\n * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of\n different lengths).\n max_length (:obj:`int`, `optional`):\n Maximum length of the returned list and optionally padding length (see above).\n pad_to_multiple_of (:obj:`int`, `optional`):\n If set will pad the sequence to a multiple of the provided value.\n\n This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >=\n 7.5 (Volta).\n \"\"\"\n\n tokenizer: PreTrainedTokenizerBase\n padding: Union[bool, str, PaddingStrategy] = True\n max_length: Optional[int] = None\n pad_to_multiple_of: Optional[int] = None\n\n def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:\n batch = self.tokenizer.pad(\n features,\n padding=self.padding,\n max_length=self.max_length,\n pad_to_multiple_of=self.pad_to_multiple_of,\n return_tensors=\"pt\",\n )\n if \"label\" in batch:\n batch[\"labels\"] = batch[\"label\"]\n del batch[\"label\"]\n if \"label_ids\" in batch:\n batch[\"labels\"] = batch[\"label_ids\"]\n del batch[\"label_ids\"]\n return batch\n\n\n@dataclass\nclass DataCollatorForTokenClassification:\n \"\"\"\n Data collator that will dynamically pad the inputs received, as well as the labels.\n\n Args:\n tokenizer (:class:`~transformers.PreTrainedTokenizer` or :class:`~transformers.PreTrainedTokenizerFast`):\n The tokenizer used for encoding the data.\n padding (:obj:`bool`, :obj:`str` or :class:`~transformers.file_utils.PaddingStrategy`, `optional`, defaults to :obj:`True`):\n Select a strategy to pad the returned sequences (according to the model's padding side and padding index)\n among:\n\n * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single\n sequence if provided).\n * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the\n maximum acceptable input length for the model if that argument is not provided.\n * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of\n different lengths).\n max_length (:obj:`int`, `optional`):\n Maximum length of the returned list and optionally padding length (see above).\n pad_to_multiple_of (:obj:`int`, `optional`):\n If set will pad the sequence to a multiple of the provided value.\n\n This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >=\n 7.5 (Volta).\n label_pad_token_id (:obj:`int`, `optional`, defaults to -100):\n The id to use when padding the labels (-100 will be automatically ignore by PyTorch loss functions).\n \"\"\"\n\n tokenizer: PreTrainedTokenizerBase\n padding: Union[bool, str, PaddingStrategy] = True\n max_length: Optional[int] = None\n pad_to_multiple_of: Optional[int] = None\n label_pad_token_id: int = -100\n\n def __call__(self, features):\n label_name = \"label\" if \"label\" in features[0].keys() else \"labels\"\n labels = [feature[label_name] for feature in features] if label_name in features[0].keys() else None\n batch = self.tokenizer.pad(\n features,\n padding=self.padding,\n max_length=self.max_length,\n pad_to_multiple_of=self.pad_to_multiple_of,\n # Conversion to tensors will fail if we have labels as they are not of the same length yet.\n return_tensors=\"pt\" if labels is None else None,\n )\n\n if labels is None:\n return batch\n\n sequence_length = torch.tensor(batch[\"input_ids\"]).shape[1]\n padding_side = self.tokenizer.padding_side\n if padding_side == \"right\":\n batch[\"labels\"] = [label + [self.label_pad_token_id] * (sequence_length - len(label)) for label in labels]\n else:\n batch[\"labels\"] = [[self.label_pad_token_id] * (sequence_length - len(label)) + label for label in labels]\n\n batch = {k: torch.tensor(v, dtype=torch.int64) for k, v in batch.items()}\n return batch\n\n\ndef _collate_batch(examples, tokenizer, pad_to_multiple_of: Optional[int] = None):\n \"\"\"Collate `examples` into a batch, using the information in `tokenizer` for padding if necessary.\"\"\"\n # Tensorize if necessary.\n if isinstance(examples[0], (list, tuple)):\n examples = [torch.tensor(e, dtype=torch.long) for e in examples]\n\n # Check if padding is necessary.\n length_of_first = examples[0].size(0)\n are_tensors_same_length = all(x.size(0) == length_of_first for x in examples)\n if are_tensors_same_length and (pad_to_multiple_of is None or length_of_first % pad_to_multiple_of == 0):\n return torch.stack(examples, dim=0)\n\n # If yes, check if we have a `pad_token`.\n if tokenizer._pad_token is None:\n raise ValueError(\n \"You are attempting to pad samples but the tokenizer you are using\"\n f\" ({tokenizer.__class__.__name__}) does not have a pad token.\"\n )\n\n # Creating the full tensor and filling it with our data.\n max_length = max(x.size(0) for x in examples)\n if pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):\n max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of\n result = examples[0].new_full([len(examples), max_length], tokenizer.pad_token_id)\n for i, example in enumerate(examples):\n if tokenizer.padding_side == \"right\":\n result[i, : example.shape[0]] = example\n else:\n result[i, -example.shape[0] :] = example\n return result\n\n\ndef tolist(x: Union[List[Any], torch.Tensor]):\n return x.tolist() if isinstance(x, torch.Tensor) else x\n\n\n@dataclass\nclass DataCollatorForSeq2Seq:\n \"\"\"\n Data collator that will dynamically pad the inputs received, as well as the labels.\n\n Args:\n tokenizer (:class:`~transformers.PreTrainedTokenizer` or :class:`~transformers.PreTrainedTokenizerFast`):\n The tokenizer used for encoding the data.\n model (:class:`~transformers.PreTrainedModel`):\n The model that is being trained. If set and has the `prepare_decoder_input_ids_from_labels`, use it to\n prepare the `decoder_input_ids`\n\n This is useful when using `label_smoothing` to avoid calculating loss twice.\n padding (:obj:`bool`, :obj:`str` or :class:`~transformers.file_utils.PaddingStrategy`, `optional`, defaults to :obj:`True`):\n Select a strategy to pad the returned sequences (according to the model's padding side and padding index)\n among:\n\n * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single\n sequence is provided).\n * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the\n maximum acceptable input length for the model if that argument is not provided.\n * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of\n different lengths).\n max_length (:obj:`int`, `optional`):\n Maximum length of the returned list and optionally padding length (see above).\n pad_to_multiple_of (:obj:`int`, `optional`):\n If set will pad the sequence to a multiple of the provided value.\n\n This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >=\n 7.5 (Volta).\n label_pad_token_id (:obj:`int`, `optional`, defaults to -100):\n The id to use when padding the labels (-100 will be automatically ignored by PyTorch loss functions).\n \"\"\"\n\n tokenizer: PreTrainedTokenizerBase\n model: Optional[PreTrainedModel] = None\n padding: Union[bool, str, PaddingStrategy] = True\n max_length: Optional[int] = None\n pad_to_multiple_of: Optional[int] = None\n label_pad_token_id: int = -100\n\n def __call__(self, features):\n labels = [feature[\"labels\"] for feature in features] if \"labels\" in features[0].keys() else None\n # We have to pad the labels before calling `tokenizer.pad` as this method won't pad them and needs them of the\n # same length to return tensors.\n if labels is not None:\n max_label_length = max(len(l) for l in labels)\n padding_side = self.tokenizer.padding_side\n for feature in features:\n remainder = [self.label_pad_token_id] * (max_label_length - len(feature[\"labels\"]))\n feature[\"labels\"] = (\n feature[\"labels\"] + remainder if padding_side == \"right\" else remainder + feature[\"labels\"]\n )\n\n features = self.tokenizer.pad(\n features,\n padding=self.padding,\n max_length=self.max_length,\n pad_to_multiple_of=self.pad_to_multiple_of,\n return_tensors=\"pt\",\n )\n\n # prepare decoder_input_ids\n if self.model is not None and hasattr(self.model, \"prepare_decoder_input_ids_from_labels\"):\n decoder_input_ids = self.model.prepare_decoder_input_ids_from_labels(labels=features[\"labels\"])\n features[\"decoder_input_ids\"] = decoder_input_ids\n\n return features\n\n\n@dataclass\nclass DataCollatorForLanguageModeling:\n \"\"\"\n Data collator used for language modeling. Inputs are dynamically padded to the maximum length of a batch if they\n are not all of the same length.\n\n Args:\n tokenizer (:class:`~transformers.PreTrainedTokenizer` or :class:`~transformers.PreTrainedTokenizerFast`):\n The tokenizer used for encoding the data.\n mlm (:obj:`bool`, `optional`, defaults to :obj:`True`):\n Whether or not to use masked language modeling. If set to :obj:`False`, the labels are the same as the\n inputs with the padding tokens ignored (by setting them to -100). Otherwise, the labels are -100 for\n non-masked tokens and the value to predict for the masked token.\n mlm_probability (:obj:`float`, `optional`, defaults to 0.15):\n The probability with which to (randomly) mask tokens in the input, when :obj:`mlm` is set to :obj:`True`.\n pad_to_multiple_of (:obj:`int`, `optional`):\n If set will pad the sequence to a multiple of the provided value.\n\n .. note::\n\n For best performance, this data collator should be used with a dataset having items that are dictionaries or\n BatchEncoding, with the :obj:`\"special_tokens_mask\"` key, as returned by a\n :class:`~transformers.PreTrainedTokenizer` or a :class:`~transformers.PreTrainedTokenizerFast` with the\n argument :obj:`return_special_tokens_mask=True`.\n \"\"\"\n\n tokenizer: PreTrainedTokenizerBase\n mlm: bool = True\n mlm_probability: float = 0.15\n pad_to_multiple_of: Optional[int] = None\n\n def __post_init__(self):\n if self.mlm and self.tokenizer.mask_token is None:\n raise ValueError(\n \"This tokenizer does not have a mask token which is necessary for masked language modeling. \"\n \"You should pass `mlm=False` to train on causal language modeling instead.\"\n )\n\n def __call__(\n self, examples: List[Union[List[int], torch.Tensor, Dict[str, torch.Tensor]]]\n ) -> Dict[str, torch.Tensor]:\n # Handle dict or lists with proper padding and conversion to tensor.\n if isinstance(examples[0], (dict, BatchEncoding)):\n batch = self.tokenizer.pad(examples, return_tensors=\"pt\", pad_to_multiple_of=self.pad_to_multiple_of)\n else:\n batch = {\"input_ids\": _collate_batch(examples, self.tokenizer, pad_to_multiple_of=self.pad_to_multiple_of)}\n\n # If special token mask has been preprocessed, pop it from the dict.\n special_tokens_mask = batch.pop(\"special_tokens_mask\", None)\n if self.mlm:\n batch[\"input_ids\"], batch[\"labels\"] = self.mask_tokens(\n batch[\"input_ids\"], special_tokens_mask=special_tokens_mask\n )\n else:\n labels = batch[\"input_ids\"].clone()\n if self.tokenizer.pad_token_id is not None:\n labels[labels == self.tokenizer.pad_token_id] = -100\n batch[\"labels\"] = labels\n return batch\n\n def mask_tokens(\n self, inputs: torch.Tensor, special_tokens_mask: Optional[torch.Tensor] = None\n ) -> Tuple[torch.Tensor, torch.Tensor]:\n \"\"\"\n Prepare masked tokens inputs/labels for masked language modeling: 80% MASK, 10% random, 10% original.\n \"\"\"\n labels = inputs.clone()\n # We sample a few tokens in each sequence for MLM training (with probability `self.mlm_probability`)\n probability_matrix = torch.full(labels.shape, self.mlm_probability)\n if special_tokens_mask is None:\n special_tokens_mask = [\n self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()\n ]\n special_tokens_mask = torch.tensor(special_tokens_mask, dtype=torch.bool)\n else:\n special_tokens_mask = special_tokens_mask.bool()\n\n probability_matrix.masked_fill_(special_tokens_mask, value=0.0)\n masked_indices = torch.bernoulli(probability_matrix).bool()\n labels[~masked_indices] = -100 # We only compute loss on masked tokens\n\n # 80% of the time, we replace masked input tokens with tokenizer.mask_token ([MASK])\n indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices\n inputs[indices_replaced] = self.tokenizer.convert_tokens_to_ids(self.tokenizer.mask_token)\n\n # 10% of the time, we replace masked input tokens with random word\n indices_random = torch.bernoulli(torch.full(labels.shape, 0.5)).bool() & masked_indices & ~indices_replaced\n random_words = torch.randint(len(self.tokenizer), labels.shape, dtype=torch.long)\n inputs[indices_random] = random_words[indices_random]\n\n # The rest of the time (10% of the time) we keep the masked input tokens unchanged\n return inputs, labels\n\n\n@dataclass\nclass DataCollatorForWholeWordMask(DataCollatorForLanguageModeling):\n \"\"\"\n Data collator used for language modeling that masks entire words.\n\n - collates batches of tensors, honoring their tokenizer's pad_token\n - preprocesses batches for masked language modeling\n\n .. note::\n\n This collator relies on details of the implementation of subword tokenization by\n :class:`~transformers.BertTokenizer`, specifically that subword tokens are prefixed with `##`. For tokenizers\n that do not adhere to this scheme, this collator will produce an output that is roughly equivalent to\n :class:`.DataCollatorForLanguageModeling`.\n \"\"\"\n\n def __call__(\n self, examples: List[Union[List[int], torch.Tensor, Dict[str, torch.Tensor]]]\n ) -> Dict[str, torch.Tensor]:\n if isinstance(examples[0], (dict, BatchEncoding)):\n input_ids = [e[\"input_ids\"] for e in examples]\n else:\n input_ids = examples\n examples = [{\"input_ids\": e} for e in examples]\n\n batch_input = _collate_batch(input_ids, self.tokenizer)\n\n mask_labels = []\n for e in examples:\n ref_tokens = []\n for id in tolist(e[\"input_ids\"]):\n token = self.tokenizer._convert_id_to_token(id)\n ref_tokens.append(token)\n\n # For Chinese tokens, we need extra inf to mark sub-word, e.g [喜,欢]-> [喜，##欢]\n if \"chinese_ref\" in e:\n ref_pos = tolist(e[\"chinese_ref\"])\n len_seq = len(e[\"input_ids\"])\n for i in range(len_seq):\n if i in ref_pos:\n ref_tokens[i] = \"##\" + ref_tokens[i]\n mask_labels.append(self._whole_word_mask(ref_tokens))\n batch_mask = _collate_batch(mask_labels, self.tokenizer)\n inputs, labels = self.mask_tokens(batch_input, batch_mask)\n return {\"input_ids\": inputs, \"labels\": labels}\n\n def _whole_word_mask(self, input_tokens: List[str], max_predictions=512):\n \"\"\"\n Get 0/1 labels for masked tokens with whole word mask proxy\n \"\"\"\n if not isinstance(self.tokenizer, (BertTokenizer, BertTokenizerFast)):\n warnings.warn(\n \"DataCollatorForWholeWordMask is only suitable for BertTokenizer-like tokenizers.\"\n \"Please refer to the documentation for more information.\"\n )\n\n cand_indexes = []\n for (i, token) in enumerate(input_tokens):\n if token == \"[CLS]\" or token == \"[SEP]\":\n continue\n\n if len(cand_indexes) >= 1 and token.startswith(\"##\"):\n cand_indexes[-1].append(i)\n else:\n cand_indexes.append([i])\n\n random.shuffle(cand_indexes)\n num_to_predict = min(max_predictions, max(1, int(round(len(input_tokens) * self.mlm_probability))))\n masked_lms = []\n covered_indexes = set()\n for index_set in cand_indexes:\n if len(masked_lms) >= num_to_predict:\n break\n # If adding a whole-word mask would exceed the maximum number of\n # predictions, then just skip this candidate.\n if len(masked_lms) + len(index_set) > num_to_predict:\n continue\n is_any_index_covered = False\n for index in index_set:\n if index in covered_indexes:\n is_any_index_covered = True\n break\n if is_any_index_covered:\n continue\n for index in index_set:\n covered_indexes.add(index)\n masked_lms.append(index)\n\n assert len(covered_indexes) == len(masked_lms)\n mask_labels = [1 if i in covered_indexes else 0 for i in range(len(input_tokens))]\n return mask_labels\n\n def mask_tokens(self, inputs: torch.Tensor, mask_labels: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n \"\"\"\n Prepare masked tokens inputs/labels for masked language modeling: 80% MASK, 10% random, 10% original. Set\n 'mask_labels' means we use whole word mask (wwm), we directly mask idxs according to it's ref.\n \"\"\"\n\n if self.tokenizer.mask_token is None:\n raise ValueError(\n \"This tokenizer does not have a mask token which is necessary for masked language modeling. Remove the --mlm flag if you want to use this tokenizer.\"\n )\n labels = inputs.clone()\n # We sample a few tokens in each sequence for masked-LM training (with probability args.mlm_probability defaults to 0.15 in Bert/RoBERTa)\n\n probability_matrix = mask_labels\n\n special_tokens_mask = [\n self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()\n ]\n probability_matrix.masked_fill_(torch.tensor(special_tokens_mask, dtype=torch.bool), value=0.0)\n if self.tokenizer._pad_token is not None:\n padding_mask = labels.eq(self.tokenizer.pad_token_id)\n probability_matrix.masked_fill_(padding_mask, value=0.0)\n\n masked_indices = probability_matrix.bool()\n labels[~masked_indices] = -100 # We only compute loss on masked tokens\n\n # 80% of the time, we replace masked input tokens with tokenizer.mask_token ([MASK])\n indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices\n inputs[indices_replaced] = self.tokenizer.convert_tokens_to_ids(self.tokenizer.mask_token)\n\n # 10% of the time, we replace masked input tokens with random word\n indices_random = torch.bernoulli(torch.full(labels.shape, 0.5)).bool() & masked_indices & ~indices_replaced\n random_words = torch.randint(len(self.tokenizer), labels.shape, dtype=torch.long)\n inputs[indices_random] = random_words[indices_random]\n\n # The rest of the time (10% of the time) we keep the masked input tokens unchanged\n return inputs, labels\n\n\n@dataclass\nclass DataCollatorForSOP(DataCollatorForLanguageModeling):\n \"\"\"\n Data collator used for sentence order prediction task.\n\n - collates batches of tensors, honoring their tokenizer's pad_token\n - preprocesses batches for both masked language modeling and sentence order prediction\n \"\"\"\n\n def __init__(self, *args, **kwargs):\n warnings.warn(\n \"DataCollatorForSOP is deprecated and will be removed in a future version, you can now use \"\n \"DataCollatorForLanguageModeling instead.\",\n FutureWarning,\n )\n\n def __call__(self, examples: List[Dict[str, torch.Tensor]]) -> Dict[str, torch.Tensor]:\n input_ids = [example[\"input_ids\"] for example in examples]\n input_ids = _collate_batch(input_ids, self.tokenizer)\n input_ids, labels, attention_mask = self.mask_tokens(input_ids)\n\n token_type_ids = [example[\"token_type_ids\"] for example in examples]\n # size of segment_ids varied because randomness, padding zero to the end as the original implementation\n token_type_ids = pad_sequence(token_type_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id)\n\n sop_label_list = [example[\"sentence_order_label\"] for example in examples]\n sentence_order_label = torch.stack(sop_label_list)\n\n return {\n \"input_ids\": input_ids,\n \"labels\": labels,\n \"attention_mask\": attention_mask,\n \"token_type_ids\": token_type_ids,\n \"sentence_order_label\": sentence_order_label,\n }\n\n def mask_tokens(self, inputs: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n \"\"\"\n Prepare masked tokens inputs/labels/attention_mask for masked language modeling: 80% MASK, 10% random, 10%\n original. N-gram not applied yet.\n \"\"\"\n if self.tokenizer.mask_token is None:\n raise ValueError(\n \"This tokenizer does not have a mask token which is necessary for masked language modeling. Remove the --mlm flag if you want to use this tokenizer.\"\n )\n\n labels = inputs.clone()\n # We sample a few tokens in each sequence for masked-LM training (with probability args.mlm_probability defaults to 0.15 in Bert/RoBERTa)\n probability_matrix = torch.full(labels.shape, self.mlm_probability)\n special_tokens_mask = [\n self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()\n ]\n probability_matrix.masked_fill_(torch.tensor(special_tokens_mask, dtype=torch.bool), value=0.0)\n if self.tokenizer._pad_token is not None:\n padding_mask = labels.eq(self.tokenizer.pad_token_id)\n probability_matrix.masked_fill_(padding_mask, value=0.0)\n masked_indices = torch.bernoulli(probability_matrix).bool()\n # probability be `1` (masked), however in albert model attention mask `0` means masked, revert the value\n attention_mask = (~masked_indices).float()\n if self.tokenizer._pad_token is not None:\n attention_padding_mask = labels.eq(self.tokenizer.pad_token_id)\n attention_mask.masked_fill_(attention_padding_mask, value=1.0)\n labels[~masked_indices] = -100 # We only compute loss on masked tokens, -100 is default for CE compute\n\n # 80% of the time, we replace masked input tokens with tokenizer.mask_token ([MASK])\n indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices\n inputs[indices_replaced] = self.tokenizer.convert_tokens_to_ids(self.tokenizer.mask_token)\n\n # 10% of the time, we replace masked input tokens with random word\n indices_random = torch.bernoulli(torch.full(labels.shape, 0.5)).bool() & masked_indices & ~indices_replaced\n random_words = torch.randint(len(self.tokenizer), labels.shape, dtype=torch.long)\n inputs[indices_random] = random_words[indices_random]\n\n # The rest of the time (10% of the time) we keep the masked input tokens unchanged\n return inputs, labels, attention_mask\n\n\n@dataclass\nclass DataCollatorForPermutationLanguageModeling:\n \"\"\"\n Data collator used for permutation language modeling.\n\n - collates batches of tensors, honoring their tokenizer's pad_token\n - preprocesses batches for permutation language modeling with procedures specific to XLNet\n \"\"\"\n\n tokenizer: PreTrainedTokenizerBase\n plm_probability: float = 1 / 6\n max_span_length: int = 5 # maximum length of a span of masked tokens\n\n def __call__(\n self, examples: List[Union[List[int], torch.Tensor, Dict[str, torch.Tensor]]]\n ) -> Dict[str, torch.Tensor]:\n if isinstance(examples[0], (dict, BatchEncoding)):\n examples = [e[\"input_ids\"] for e in examples]\n batch = _collate_batch(examples, self.tokenizer)\n inputs, perm_mask, target_mapping, labels = self.mask_tokens(batch)\n return {\"input_ids\": inputs, \"perm_mask\": perm_mask, \"target_mapping\": target_mapping, \"labels\": labels}\n\n def mask_tokens(self, inputs: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\n \"\"\"\n The masked tokens to be predicted for a particular sequence are determined by the following algorithm:\n\n 0. Start from the beginning of the sequence by setting ``cur_len = 0`` (number of tokens processed so far).\n 1. Sample a ``span_length`` from the interval ``[1, max_span_length]`` (length of span of tokens to be\n masked)\n 2. Reserve a context of length ``context_length = span_length / plm_probability`` to surround span to be\n masked\n 3. Sample a starting point ``start_index`` from the interval ``[cur_len, cur_len + context_length -\n span_length]`` and mask tokens ``start_index:start_index + span_length``\n 4. Set ``cur_len = cur_len + context_length``. If ``cur_len < max_len`` (i.e. there are tokens remaining in\n the sequence to be processed), repeat from Step 1.\n \"\"\"\n\n if self.tokenizer.mask_token is None:\n raise ValueError(\n \"This tokenizer does not have a mask token which is necessary for permutation language modeling. Please add a mask token if you want to use this tokenizer.\"\n )\n\n if inputs.size(1) % 2 != 0:\n raise ValueError(\n \"This collator requires that sequence lengths be even to create a leakage-free perm_mask. Please see relevant comments in source code for details.\"\n )\n\n labels = inputs.clone()\n # Creating the mask and target_mapping tensors\n masked_indices = torch.full(labels.shape, 0, dtype=torch.bool)\n target_mapping = torch.zeros((labels.size(0), labels.size(1), labels.size(1)), dtype=torch.float32)\n\n for i in range(labels.size(0)):\n # Start from the beginning of the sequence by setting `cur_len = 0` (number of tokens processed so far).\n cur_len = 0\n max_len = labels.size(1)\n\n while cur_len < max_len:\n # Sample a `span_length` from the interval `[1, max_span_length]` (length of span of tokens to be masked)\n span_length = torch.randint(1, self.max_span_length + 1, (1,)).item()\n # Reserve a context of length `context_length = span_length / plm_probability` to surround the span to be masked\n context_length = int(span_length / self.plm_probability)\n # Sample a starting point `start_index` from the interval `[cur_len, cur_len + context_length - span_length]` and mask tokens `start_index:start_index + span_length`\n start_index = cur_len + torch.randint(context_length - span_length + 1, (1,)).item()\n masked_indices[i, start_index : start_index + span_length] = 1\n # Set `cur_len = cur_len + context_length`\n cur_len += context_length\n\n # Since we're replacing non-masked tokens with -100 in the labels tensor instead of skipping them altogether,\n # the i-th predict corresponds to the i-th token.\n target_mapping[i] = torch.eye(labels.size(1))\n\n special_tokens_mask = torch.tensor(\n [self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()],\n dtype=torch.bool,\n )\n masked_indices.masked_fill_(special_tokens_mask, value=0.0)\n if self.tokenizer._pad_token is not None:\n padding_mask = labels.eq(self.tokenizer.pad_token_id)\n masked_indices.masked_fill_(padding_mask, value=0.0)\n\n # Mask indicating non-functional tokens, where functional tokens are [SEP], [CLS], padding, etc.\n non_func_mask = ~(padding_mask | special_tokens_mask)\n\n inputs[masked_indices] = self.tokenizer.mask_token_id\n labels[~masked_indices] = -100 # We only compute loss on masked tokens\n\n perm_mask = torch.zeros((labels.size(0), labels.size(1), labels.size(1)), dtype=torch.float32)\n\n for i in range(labels.size(0)):\n # Generate permutation indices i.e. sample a random factorisation order for the sequence. This will\n # determine which tokens a given token can attend to (encoded in `perm_mask`).\n # Note: Length of token sequence being permuted has to be less than or equal to reused sequence length\n # (see documentation for `mems`), otherwise information may leak through due to reuse. In this implementation,\n # we assume that reused length is half of sequence length and permutation length is equal to reused length.\n # This requires that the sequence length be even.\n\n # Create a linear factorisation order\n perm_index = torch.arange(labels.size(1))\n # Split this into two halves, assuming that half the sequence is reused each time\n perm_index = perm_index.reshape((-1, labels.size(1) // 2)).transpose(0, 1)\n # Permute the two halves such that they do not cross over\n perm_index = perm_index[torch.randperm(labels.size(1) // 2)]\n # Flatten this out into the desired permuted factorisation order\n perm_index = torch.flatten(perm_index.transpose(0, 1))\n # Set the permutation indices of non-masked (non-functional) tokens to the\n # smallest index (-1) so that:\n # (1) They can be seen by all other positions\n # (2) They cannot see masked positions, so there won't be information leak\n perm_index.masked_fill_(~masked_indices[i] & non_func_mask[i], -1)\n # The logic for whether the i-th token can attend on the j-th token based on the factorisation order:\n # 0 (can attend): If perm_index[i] > perm_index[j] or j is neither masked nor a functional token\n # 1 (cannot attend): If perm_index[i] <= perm_index[j] and j is either masked or a functional token\n perm_mask[i] = (\n perm_index.reshape((labels.size(1), 1)) <= perm_index.reshape((1, labels.size(1)))\n ) & masked_indices[i]\n\n return inputs.long(), perm_mask, target_mapping, labels.long()"},"implementation":{"kind":"string","value":"def default_data_collator(features: List[InputDataClass]) -> Dict[str, torch.Tensor]:\n \"\"\"\n Very simple data collator that simply collates batches of dict-like objects and performs special handling for\n potential keys named:\n\n - ``label``: handles a single value (int or float) per object\n - ``label_ids``: handles a list of values per object\n\n Does not do any additional preprocessing: property names of the input object will be used as corresponding inputs\n to the model. See glue and ner for example of how it's useful.\n \"\"\"\n\n # In this function we'll make the assumption that all `features` in the batch\n # have the same attributes.\n # So we will look at the first element as a proxy for what attributes exist\n # on the whole batch.\n if not isinstance(features[0], (dict, BatchEncoding)):\n features = [vars(f) for f in features]\n\n first = features[0]\n batch = {}\n\n # Special handling for labels.\n # Ensure that tensor is created with the correct type\n # (it should be automatically the case, but let's make sure of it.)\n if \"label\" in first and first[\"label\"] is not None:\n label = first[\"label\"].item() if isinstance(first[\"label\"], torch.Tensor) else first[\"label\"]\n dtype = torch.long if isinstance(label, int) else torch.float\n batch[\"labels\"] = torch.tensor([f[\"label\"] for f in features], dtype=dtype)\n elif \"label_ids\" in first and first[\"label_ids\"] is not None:\n if isinstance(first[\"label_ids\"], torch.Tensor):\n batch[\"labels\"] = torch.stack([f[\"label_ids\"] for f in features])\n else:\n dtype = torch.long if type(first[\"label_ids\"][0]) is int else torch.float\n batch[\"labels\"] = torch.tensor([f[\"label_ids\"] for f in features], dtype=dtype)\n\n # Handling of all other possible keys.\n # Again, we will use the first element to figure out which key/values are not None for this model.\n for k, v in first.items():\n if k not in (\"label\", \"label_ids\") and v is not None and not isinstance(v, str):\n if isinstance(v, torch.Tensor):\n batch[k] = torch.stack([f[k] for f in features])\n else:\n batch[k] = torch.tensor([f[k] for f in features])\n\n return batch"},"start_line":{"kind":"number","value":38,"string":"38"},"end_line":{"kind":"number","value":83,"string":"83"},"file_content":{"kind":"string","value":"# Copyright 2020 The HuggingFace Team. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport random\nimport warnings\nfrom dataclasses import dataclass\nfrom typing import Any, Callable, Dict, List, NewType, Optional, Tuple, Union\n\nimport torch\nfrom torch.nn.utils.rnn import pad_sequence\n\nfrom ..file_utils import PaddingStrategy\nfrom ..modeling_utils import PreTrainedModel\nfrom ..models.bert import BertTokenizer, BertTokenizerFast\nfrom ..tokenization_utils_base import BatchEncoding, PreTrainedTokenizerBase\n\n\nInputDataClass = NewType(\"InputDataClass\", Any)\n\n\"\"\"\nA DataCollator is a function that takes a list of samples from a Dataset and collate them into a batch, as a dictionary\nof Tensors.\n\"\"\"\nDataCollator = NewType(\"DataCollator\", Callable[[List[InputDataClass]], Dict[str, torch.Tensor]])\n\n\ndef default_data_collator(features: List[InputDataClass]) -> Dict[str, torch.Tensor]:\n \"\"\"\n Very simple data collator that simply collates batches of dict-like objects and performs special handling for\n potential keys named:\n\n - ``label``: handles a single value (int or float) per object\n - ``label_ids``: handles a list of values per object\n\n Does not do any additional preprocessing: property names of the input object will be used as corresponding inputs\n to the model. See glue and ner for example of how it's useful.\n \"\"\"\n\n # In this function we'll make the assumption that all `features` in the batch\n # have the same attributes.\n # So we will look at the first element as a proxy for what attributes exist\n # on the whole batch.\n if not isinstance(features[0], (dict, BatchEncoding)):\n features = [vars(f) for f in features]\n\n first = features[0]\n batch = {}\n\n # Special handling for labels.\n # Ensure that tensor is created with the correct type\n # (it should be automatically the case, but let's make sure of it.)\n if \"label\" in first and first[\"label\"] is not None:\n label = first[\"label\"].item() if isinstance(first[\"label\"], torch.Tensor) else first[\"label\"]\n dtype = torch.long if isinstance(label, int) else torch.float\n batch[\"labels\"] = torch.tensor([f[\"label\"] for f in features], dtype=dtype)\n elif \"label_ids\" in first and first[\"label_ids\"] is not None:\n if isinstance(first[\"label_ids\"], torch.Tensor):\n batch[\"labels\"] = torch.stack([f[\"label_ids\"] for f in features])\n else:\n dtype = torch.long if type(first[\"label_ids\"][0]) is int else torch.float\n batch[\"labels\"] = torch.tensor([f[\"label_ids\"] for f in features], dtype=dtype)\n\n # Handling of all other possible keys.\n # Again, we will use the first element to figure out which key/values are not None for this model.\n for k, v in first.items():\n if k not in (\"label\", \"label_ids\") and v is not None and not isinstance(v, str):\n if isinstance(v, torch.Tensor):\n batch[k] = torch.stack([f[k] for f in features])\n else:\n batch[k] = torch.tensor([f[k] for f in features])\n\n return batch\n\n\n@dataclass\nclass DataCollatorWithPadding:\n \"\"\"\n Data collator that will dynamically pad the inputs received.\n\n Args:\n tokenizer (:class:`~transformers.PreTrainedTokenizer` or :class:`~transformers.PreTrainedTokenizerFast`):\n The tokenizer used for encoding the data.\n padding (:obj:`bool`, :obj:`str` or :class:`~transformers.file_utils.PaddingStrategy`, `optional`, defaults to :obj:`True`):\n Select a strategy to pad the returned sequences (according to the model's padding side and padding index)\n among:\n\n * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single\n sequence if provided).\n * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the\n maximum acceptable input length for the model if that argument is not provided.\n * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of\n different lengths).\n max_length (:obj:`int`, `optional`):\n Maximum length of the returned list and optionally padding length (see above).\n pad_to_multiple_of (:obj:`int`, `optional`):\n If set will pad the sequence to a multiple of the provided value.\n\n This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >=\n 7.5 (Volta).\n \"\"\"\n\n tokenizer: PreTrainedTokenizerBase\n padding: Union[bool, str, PaddingStrategy] = True\n max_length: Optional[int] = None\n pad_to_multiple_of: Optional[int] = None\n\n def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:\n batch = self.tokenizer.pad(\n features,\n padding=self.padding,\n max_length=self.max_length,\n pad_to_multiple_of=self.pad_to_multiple_of,\n return_tensors=\"pt\",\n )\n if \"label\" in batch:\n batch[\"labels\"] = batch[\"label\"]\n del batch[\"label\"]\n if \"label_ids\" in batch:\n batch[\"labels\"] = batch[\"label_ids\"]\n del batch[\"label_ids\"]\n return batch\n\n\n@dataclass\nclass DataCollatorForTokenClassification:\n \"\"\"\n Data collator that will dynamically pad the inputs received, as well as the labels.\n\n Args:\n tokenizer (:class:`~transformers.PreTrainedTokenizer` or :class:`~transformers.PreTrainedTokenizerFast`):\n The tokenizer used for encoding the data.\n padding (:obj:`bool`, :obj:`str` or :class:`~transformers.file_utils.PaddingStrategy`, `optional`, defaults to :obj:`True`):\n Select a strategy to pad the returned sequences (according to the model's padding side and padding index)\n among:\n\n * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single\n sequence if provided).\n * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the\n maximum acceptable input length for the model if that argument is not provided.\n * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of\n different lengths).\n max_length (:obj:`int`, `optional`):\n Maximum length of the returned list and optionally padding length (see above).\n pad_to_multiple_of (:obj:`int`, `optional`):\n If set will pad the sequence to a multiple of the provided value.\n\n This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >=\n 7.5 (Volta).\n label_pad_token_id (:obj:`int`, `optional`, defaults to -100):\n The id to use when padding the labels (-100 will be automatically ignore by PyTorch loss functions).\n \"\"\"\n\n tokenizer: PreTrainedTokenizerBase\n padding: Union[bool, str, PaddingStrategy] = True\n max_length: Optional[int] = None\n pad_to_multiple_of: Optional[int] = None\n label_pad_token_id: int = -100\n\n def __call__(self, features):\n label_name = \"label\" if \"label\" in features[0].keys() else \"labels\"\n labels = [feature[label_name] for feature in features] if label_name in features[0].keys() else None\n batch = self.tokenizer.pad(\n features,\n padding=self.padding,\n max_length=self.max_length,\n pad_to_multiple_of=self.pad_to_multiple_of,\n # Conversion to tensors will fail if we have labels as they are not of the same length yet.\n return_tensors=\"pt\" if labels is None else None,\n )\n\n if labels is None:\n return batch\n\n sequence_length = torch.tensor(batch[\"input_ids\"]).shape[1]\n padding_side = self.tokenizer.padding_side\n if padding_side == \"right\":\n batch[\"labels\"] = [label + [self.label_pad_token_id] * (sequence_length - len(label)) for label in labels]\n else:\n batch[\"labels\"] = [[self.label_pad_token_id] * (sequence_length - len(label)) + label for label in labels]\n\n batch = {k: torch.tensor(v, dtype=torch.int64) for k, v in batch.items()}\n return batch\n\n\ndef _collate_batch(examples, tokenizer, pad_to_multiple_of: Optional[int] = None):\n \"\"\"Collate `examples` into a batch, using the information in `tokenizer` for padding if necessary.\"\"\"\n # Tensorize if necessary.\n if isinstance(examples[0], (list, tuple)):\n examples = [torch.tensor(e, dtype=torch.long) for e in examples]\n\n # Check if padding is necessary.\n length_of_first = examples[0].size(0)\n are_tensors_same_length = all(x.size(0) == length_of_first for x in examples)\n if are_tensors_same_length and (pad_to_multiple_of is None or length_of_first % pad_to_multiple_of == 0):\n return torch.stack(examples, dim=0)\n\n # If yes, check if we have a `pad_token`.\n if tokenizer._pad_token is None:\n raise ValueError(\n \"You are attempting to pad samples but the tokenizer you are using\"\n f\" ({tokenizer.__class__.__name__}) does not have a pad token.\"\n )\n\n # Creating the full tensor and filling it with our data.\n max_length = max(x.size(0) for x in examples)\n if pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):\n max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of\n result = examples[0].new_full([len(examples), max_length], tokenizer.pad_token_id)\n for i, example in enumerate(examples):\n if tokenizer.padding_side == \"right\":\n result[i, : example.shape[0]] = example\n else:\n result[i, -example.shape[0] :] = example\n return result\n\n\ndef tolist(x: Union[List[Any], torch.Tensor]):\n return x.tolist() if isinstance(x, torch.Tensor) else x\n\n\n@dataclass\nclass DataCollatorForSeq2Seq:\n \"\"\"\n Data collator that will dynamically pad the inputs received, as well as the labels.\n\n Args:\n tokenizer (:class:`~transformers.PreTrainedTokenizer` or :class:`~transformers.PreTrainedTokenizerFast`):\n The tokenizer used for encoding the data.\n model (:class:`~transformers.PreTrainedModel`):\n The model that is being trained. If set and has the `prepare_decoder_input_ids_from_labels`, use it to\n prepare the `decoder_input_ids`\n\n This is useful when using `label_smoothing` to avoid calculating loss twice.\n padding (:obj:`bool`, :obj:`str` or :class:`~transformers.file_utils.PaddingStrategy`, `optional`, defaults to :obj:`True`):\n Select a strategy to pad the returned sequences (according to the model's padding side and padding index)\n among:\n\n * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single\n sequence is provided).\n * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the\n maximum acceptable input length for the model if that argument is not provided.\n * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of\n different lengths).\n max_length (:obj:`int`, `optional`):\n Maximum length of the returned list and optionally padding length (see above).\n pad_to_multiple_of (:obj:`int`, `optional`):\n If set will pad the sequence to a multiple of the provided value.\n\n This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >=\n 7.5 (Volta).\n label_pad_token_id (:obj:`int`, `optional`, defaults to -100):\n The id to use when padding the labels (-100 will be automatically ignored by PyTorch loss functions).\n \"\"\"\n\n tokenizer: PreTrainedTokenizerBase\n model: Optional[PreTrainedModel] = None\n padding: Union[bool, str, PaddingStrategy] = True\n max_length: Optional[int] = None\n pad_to_multiple_of: Optional[int] = None\n label_pad_token_id: int = -100\n\n def __call__(self, features):\n labels = [feature[\"labels\"] for feature in features] if \"labels\" in features[0].keys() else None\n # We have to pad the labels before calling `tokenizer.pad` as this method won't pad them and needs them of the\n # same length to return tensors.\n if labels is not None:\n max_label_length = max(len(l) for l in labels)\n padding_side = self.tokenizer.padding_side\n for feature in features:\n remainder = [self.label_pad_token_id] * (max_label_length - len(feature[\"labels\"]))\n feature[\"labels\"] = (\n feature[\"labels\"] + remainder if padding_side == \"right\" else remainder + feature[\"labels\"]\n )\n\n features = self.tokenizer.pad(\n features,\n padding=self.padding,\n max_length=self.max_length,\n pad_to_multiple_of=self.pad_to_multiple_of,\n return_tensors=\"pt\",\n )\n\n # prepare decoder_input_ids\n if self.model is not None and hasattr(self.model, \"prepare_decoder_input_ids_from_labels\"):\n decoder_input_ids = self.model.prepare_decoder_input_ids_from_labels(labels=features[\"labels\"])\n features[\"decoder_input_ids\"] = decoder_input_ids\n\n return features\n\n\n@dataclass\nclass DataCollatorForLanguageModeling:\n \"\"\"\n Data collator used for language modeling. Inputs are dynamically padded to the maximum length of a batch if they\n are not all of the same length.\n\n Args:\n tokenizer (:class:`~transformers.PreTrainedTokenizer` or :class:`~transformers.PreTrainedTokenizerFast`):\n The tokenizer used for encoding the data.\n mlm (:obj:`bool`, `optional`, defaults to :obj:`True`):\n Whether or not to use masked language modeling. If set to :obj:`False`, the labels are the same as the\n inputs with the padding tokens ignored (by setting them to -100). Otherwise, the labels are -100 for\n non-masked tokens and the value to predict for the masked token.\n mlm_probability (:obj:`float`, `optional`, defaults to 0.15):\n The probability with which to (randomly) mask tokens in the input, when :obj:`mlm` is set to :obj:`True`.\n pad_to_multiple_of (:obj:`int`, `optional`):\n If set will pad the sequence to a multiple of the provided value.\n\n .. note::\n\n For best performance, this data collator should be used with a dataset having items that are dictionaries or\n BatchEncoding, with the :obj:`\"special_tokens_mask\"` key, as returned by a\n :class:`~transformers.PreTrainedTokenizer` or a :class:`~transformers.PreTrainedTokenizerFast` with the\n argument :obj:`return_special_tokens_mask=True`.\n \"\"\"\n\n tokenizer: PreTrainedTokenizerBase\n mlm: bool = True\n mlm_probability: float = 0.15\n pad_to_multiple_of: Optional[int] = None\n\n def __post_init__(self):\n if self.mlm and self.tokenizer.mask_token is None:\n raise ValueError(\n \"This tokenizer does not have a mask token which is necessary for masked language modeling. \"\n \"You should pass `mlm=False` to train on causal language modeling instead.\"\n )\n\n def __call__(\n self, examples: List[Union[List[int], torch.Tensor, Dict[str, torch.Tensor]]]\n ) -> Dict[str, torch.Tensor]:\n # Handle dict or lists with proper padding and conversion to tensor.\n if isinstance(examples[0], (dict, BatchEncoding)):\n batch = self.tokenizer.pad(examples, return_tensors=\"pt\", pad_to_multiple_of=self.pad_to_multiple_of)\n else:\n batch = {\"input_ids\": _collate_batch(examples, self.tokenizer, pad_to_multiple_of=self.pad_to_multiple_of)}\n\n # If special token mask has been preprocessed, pop it from the dict.\n special_tokens_mask = batch.pop(\"special_tokens_mask\", None)\n if self.mlm:\n batch[\"input_ids\"], batch[\"labels\"] = self.mask_tokens(\n batch[\"input_ids\"], special_tokens_mask=special_tokens_mask\n )\n else:\n labels = batch[\"input_ids\"].clone()\n if self.tokenizer.pad_token_id is not None:\n labels[labels == self.tokenizer.pad_token_id] = -100\n batch[\"labels\"] = labels\n return batch\n\n def mask_tokens(\n self, inputs: torch.Tensor, special_tokens_mask: Optional[torch.Tensor] = None\n ) -> Tuple[torch.Tensor, torch.Tensor]:\n \"\"\"\n Prepare masked tokens inputs/labels for masked language modeling: 80% MASK, 10% random, 10% original.\n \"\"\"\n labels = inputs.clone()\n # We sample a few tokens in each sequence for MLM training (with probability `self.mlm_probability`)\n probability_matrix = torch.full(labels.shape, self.mlm_probability)\n if special_tokens_mask is None:\n special_tokens_mask = [\n self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()\n ]\n special_tokens_mask = torch.tensor(special_tokens_mask, dtype=torch.bool)\n else:\n special_tokens_mask = special_tokens_mask.bool()\n\n probability_matrix.masked_fill_(special_tokens_mask, value=0.0)\n masked_indices = torch.bernoulli(probability_matrix).bool()\n labels[~masked_indices] = -100 # We only compute loss on masked tokens\n\n # 80% of the time, we replace masked input tokens with tokenizer.mask_token ([MASK])\n indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices\n inputs[indices_replaced] = self.tokenizer.convert_tokens_to_ids(self.tokenizer.mask_token)\n\n # 10% of the time, we replace masked input tokens with random word\n indices_random = torch.bernoulli(torch.full(labels.shape, 0.5)).bool() & masked_indices & ~indices_replaced\n random_words = torch.randint(len(self.tokenizer), labels.shape, dtype=torch.long)\n inputs[indices_random] = random_words[indices_random]\n\n # The rest of the time (10% of the time) we keep the masked input tokens unchanged\n return inputs, labels\n\n\n@dataclass\nclass DataCollatorForWholeWordMask(DataCollatorForLanguageModeling):\n \"\"\"\n Data collator used for language modeling that masks entire words.\n\n - collates batches of tensors, honoring their tokenizer's pad_token\n - preprocesses batches for masked language modeling\n\n .. note::\n\n This collator relies on details of the implementation of subword tokenization by\n :class:`~transformers.BertTokenizer`, specifically that subword tokens are prefixed with `##`. For tokenizers\n that do not adhere to this scheme, this collator will produce an output that is roughly equivalent to\n :class:`.DataCollatorForLanguageModeling`.\n \"\"\"\n\n def __call__(\n self, examples: List[Union[List[int], torch.Tensor, Dict[str, torch.Tensor]]]\n ) -> Dict[str, torch.Tensor]:\n if isinstance(examples[0], (dict, BatchEncoding)):\n input_ids = [e[\"input_ids\"] for e in examples]\n else:\n input_ids = examples\n examples = [{\"input_ids\": e} for e in examples]\n\n batch_input = _collate_batch(input_ids, self.tokenizer)\n\n mask_labels = []\n for e in examples:\n ref_tokens = []\n for id in tolist(e[\"input_ids\"]):\n token = self.tokenizer._convert_id_to_token(id)\n ref_tokens.append(token)\n\n # For Chinese tokens, we need extra inf to mark sub-word, e.g [喜,欢]-> [喜，##欢]\n if \"chinese_ref\" in e:\n ref_pos = tolist(e[\"chinese_ref\"])\n len_seq = len(e[\"input_ids\"])\n for i in range(len_seq):\n if i in ref_pos:\n ref_tokens[i] = \"##\" + ref_tokens[i]\n mask_labels.append(self._whole_word_mask(ref_tokens))\n batch_mask = _collate_batch(mask_labels, self.tokenizer)\n inputs, labels = self.mask_tokens(batch_input, batch_mask)\n return {\"input_ids\": inputs, \"labels\": labels}\n\n def _whole_word_mask(self, input_tokens: List[str], max_predictions=512):\n \"\"\"\n Get 0/1 labels for masked tokens with whole word mask proxy\n \"\"\"\n if not isinstance(self.tokenizer, (BertTokenizer, BertTokenizerFast)):\n warnings.warn(\n \"DataCollatorForWholeWordMask is only suitable for BertTokenizer-like tokenizers.\"\n \"Please refer to the documentation for more information.\"\n )\n\n cand_indexes = []\n for (i, token) in enumerate(input_tokens):\n if token == \"[CLS]\" or token == \"[SEP]\":\n continue\n\n if len(cand_indexes) >= 1 and token.startswith(\"##\"):\n cand_indexes[-1].append(i)\n else:\n cand_indexes.append([i])\n\n random.shuffle(cand_indexes)\n num_to_predict = min(max_predictions, max(1, int(round(len(input_tokens) * self.mlm_probability))))\n masked_lms = []\n covered_indexes = set()\n for index_set in cand_indexes:\n if len(masked_lms) >= num_to_predict:\n break\n # If adding a whole-word mask would exceed the maximum number of\n # predictions, then just skip this candidate.\n if len(masked_lms) + len(index_set) > num_to_predict:\n continue\n is_any_index_covered = False\n for index in index_set:\n if index in covered_indexes:\n is_any_index_covered = True\n break\n if is_any_index_covered:\n continue\n for index in index_set:\n covered_indexes.add(index)\n masked_lms.append(index)\n\n assert len(covered_indexes) == len(masked_lms)\n mask_labels = [1 if i in covered_indexes else 0 for i in range(len(input_tokens))]\n return mask_labels\n\n def mask_tokens(self, inputs: torch.Tensor, mask_labels: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n \"\"\"\n Prepare masked tokens inputs/labels for masked language modeling: 80% MASK, 10% random, 10% original. Set\n 'mask_labels' means we use whole word mask (wwm), we directly mask idxs according to it's ref.\n \"\"\"\n\n if self.tokenizer.mask_token is None:\n raise ValueError(\n \"This tokenizer does not have a mask token which is necessary for masked language modeling. Remove the --mlm flag if you want to use this tokenizer.\"\n )\n labels = inputs.clone()\n # We sample a few tokens in each sequence for masked-LM training (with probability args.mlm_probability defaults to 0.15 in Bert/RoBERTa)\n\n probability_matrix = mask_labels\n\n special_tokens_mask = [\n self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()\n ]\n probability_matrix.masked_fill_(torch.tensor(special_tokens_mask, dtype=torch.bool), value=0.0)\n if self.tokenizer._pad_token is not None:\n padding_mask = labels.eq(self.tokenizer.pad_token_id)\n probability_matrix.masked_fill_(padding_mask, value=0.0)\n\n masked_indices = probability_matrix.bool()\n labels[~masked_indices] = -100 # We only compute loss on masked tokens\n\n # 80% of the time, we replace masked input tokens with tokenizer.mask_token ([MASK])\n indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices\n inputs[indices_replaced] = self.tokenizer.convert_tokens_to_ids(self.tokenizer.mask_token)\n\n # 10% of the time, we replace masked input tokens with random word\n indices_random = torch.bernoulli(torch.full(labels.shape, 0.5)).bool() & masked_indices & ~indices_replaced\n random_words = torch.randint(len(self.tokenizer), labels.shape, dtype=torch.long)\n inputs[indices_random] = random_words[indices_random]\n\n # The rest of the time (10% of the time) we keep the masked input tokens unchanged\n return inputs, labels\n\n\n@dataclass\nclass DataCollatorForSOP(DataCollatorForLanguageModeling):\n \"\"\"\n Data collator used for sentence order prediction task.\n\n - collates batches of tensors, honoring their tokenizer's pad_token\n - preprocesses batches for both masked language modeling and sentence order prediction\n \"\"\"\n\n def __init__(self, *args, **kwargs):\n warnings.warn(\n \"DataCollatorForSOP is deprecated and will be removed in a future version, you can now use \"\n \"DataCollatorForLanguageModeling instead.\",\n FutureWarning,\n )\n\n def __call__(self, examples: List[Dict[str, torch.Tensor]]) -> Dict[str, torch.Tensor]:\n input_ids = [example[\"input_ids\"] for example in examples]\n input_ids = _collate_batch(input_ids, self.tokenizer)\n input_ids, labels, attention_mask = self.mask_tokens(input_ids)\n\n token_type_ids = [example[\"token_type_ids\"] for example in examples]\n # size of segment_ids varied because randomness, padding zero to the end as the original implementation\n token_type_ids = pad_sequence(token_type_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id)\n\n sop_label_list = [example[\"sentence_order_label\"] for example in examples]\n sentence_order_label = torch.stack(sop_label_list)\n\n return {\n \"input_ids\": input_ids,\n \"labels\": labels,\n \"attention_mask\": attention_mask,\n \"token_type_ids\": token_type_ids,\n \"sentence_order_label\": sentence_order_label,\n }\n\n def mask_tokens(self, inputs: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n \"\"\"\n Prepare masked tokens inputs/labels/attention_mask for masked language modeling: 80% MASK, 10% random, 10%\n original. N-gram not applied yet.\n \"\"\"\n if self.tokenizer.mask_token is None:\n raise ValueError(\n \"This tokenizer does not have a mask token which is necessary for masked language modeling. Remove the --mlm flag if you want to use this tokenizer.\"\n )\n\n labels = inputs.clone()\n # We sample a few tokens in each sequence for masked-LM training (with probability args.mlm_probability defaults to 0.15 in Bert/RoBERTa)\n probability_matrix = torch.full(labels.shape, self.mlm_probability)\n special_tokens_mask = [\n self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()\n ]\n probability_matrix.masked_fill_(torch.tensor(special_tokens_mask, dtype=torch.bool), value=0.0)\n if self.tokenizer._pad_token is not None:\n padding_mask = labels.eq(self.tokenizer.pad_token_id)\n probability_matrix.masked_fill_(padding_mask, value=0.0)\n masked_indices = torch.bernoulli(probability_matrix).bool()\n # probability be `1` (masked), however in albert model attention mask `0` means masked, revert the value\n attention_mask = (~masked_indices).float()\n if self.tokenizer._pad_token is not None:\n attention_padding_mask = labels.eq(self.tokenizer.pad_token_id)\n attention_mask.masked_fill_(attention_padding_mask, value=1.0)\n labels[~masked_indices] = -100 # We only compute loss on masked tokens, -100 is default for CE compute\n\n # 80% of the time, we replace masked input tokens with tokenizer.mask_token ([MASK])\n indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices\n inputs[indices_replaced] = self.tokenizer.convert_tokens_to_ids(self.tokenizer.mask_token)\n\n # 10% of the time, we replace masked input tokens with random word\n indices_random = torch.bernoulli(torch.full(labels.shape, 0.5)).bool() & masked_indices & ~indices_replaced\n random_words = torch.randint(len(self.tokenizer), labels.shape, dtype=torch.long)\n inputs[indices_random] = random_words[indices_random]\n\n # The rest of the time (10% of the time) we keep the masked input tokens unchanged\n return inputs, labels, attention_mask\n\n\n@dataclass\nclass DataCollatorForPermutationLanguageModeling:\n \"\"\"\n Data collator used for permutation language modeling.\n\n - collates batches of tensors, honoring their tokenizer's pad_token\n - preprocesses batches for permutation language modeling with procedures specific to XLNet\n \"\"\"\n\n tokenizer: PreTrainedTokenizerBase\n plm_probability: float = 1 / 6\n max_span_length: int = 5 # maximum length of a span of masked tokens\n\n def __call__(\n self, examples: List[Union[List[int], torch.Tensor, Dict[str, torch.Tensor]]]\n ) -> Dict[str, torch.Tensor]:\n if isinstance(examples[0], (dict, BatchEncoding)):\n examples = [e[\"input_ids\"] for e in examples]\n batch = _collate_batch(examples, self.tokenizer)\n inputs, perm_mask, target_mapping, labels = self.mask_tokens(batch)\n return {\"input_ids\": inputs, \"perm_mask\": perm_mask, \"target_mapping\": target_mapping, \"labels\": labels}\n\n def mask_tokens(self, inputs: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\n \"\"\"\n The masked tokens to be predicted for a particular sequence are determined by the following algorithm:\n\n 0. Start from the beginning of the sequence by setting ``cur_len = 0`` (number of tokens processed so far).\n 1. Sample a ``span_length`` from the interval ``[1, max_span_length]`` (length of span of tokens to be\n masked)\n 2. Reserve a context of length ``context_length = span_length / plm_probability`` to surround span to be\n masked\n 3. Sample a starting point ``start_index`` from the interval ``[cur_len, cur_len + context_length -\n span_length]`` and mask tokens ``start_index:start_index + span_length``\n 4. Set ``cur_len = cur_len + context_length``. If ``cur_len < max_len`` (i.e. there are tokens remaining in\n the sequence to be processed), repeat from Step 1.\n \"\"\"\n\n if self.tokenizer.mask_token is None:\n raise ValueError(\n \"This tokenizer does not have a mask token which is necessary for permutation language modeling. Please add a mask token if you want to use this tokenizer.\"\n )\n\n if inputs.size(1) % 2 != 0:\n raise ValueError(\n \"This collator requires that sequence lengths be even to create a leakage-free perm_mask. Please see relevant comments in source code for details.\"\n )\n\n labels = inputs.clone()\n # Creating the mask and target_mapping tensors\n masked_indices = torch.full(labels.shape, 0, dtype=torch.bool)\n target_mapping = torch.zeros((labels.size(0), labels.size(1), labels.size(1)), dtype=torch.float32)\n\n for i in range(labels.size(0)):\n # Start from the beginning of the sequence by setting `cur_len = 0` (number of tokens processed so far).\n cur_len = 0\n max_len = labels.size(1)\n\n while cur_len < max_len:\n # Sample a `span_length` from the interval `[1, max_span_length]` (length of span of tokens to be masked)\n span_length = torch.randint(1, self.max_span_length + 1, (1,)).item()\n # Reserve a context of length `context_length = span_length / plm_probability` to surround the span to be masked\n context_length = int(span_length / self.plm_probability)\n # Sample a starting point `start_index` from the interval `[cur_len, cur_len + context_length - span_length]` and mask tokens `start_index:start_index + span_length`\n start_index = cur_len + torch.randint(context_length - span_length + 1, (1,)).item()\n masked_indices[i, start_index : start_index + span_length] = 1\n # Set `cur_len = cur_len + context_length`\n cur_len += context_length\n\n # Since we're replacing non-masked tokens with -100 in the labels tensor instead of skipping them altogether,\n # the i-th predict corresponds to the i-th token.\n target_mapping[i] = torch.eye(labels.size(1))\n\n special_tokens_mask = torch.tensor(\n [self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()],\n dtype=torch.bool,\n )\n masked_indices.masked_fill_(special_tokens_mask, value=0.0)\n if self.tokenizer._pad_token is not None:\n padding_mask = labels.eq(self.tokenizer.pad_token_id)\n masked_indices.masked_fill_(padding_mask, value=0.0)\n\n # Mask indicating non-functional tokens, where functional tokens are [SEP], [CLS], padding, etc.\n non_func_mask = ~(padding_mask | special_tokens_mask)\n\n inputs[masked_indices] = self.tokenizer.mask_token_id\n labels[~masked_indices] = -100 # We only compute loss on masked tokens\n\n perm_mask = torch.zeros((labels.size(0), labels.size(1), labels.size(1)), dtype=torch.float32)\n\n for i in range(labels.size(0)):\n # Generate permutation indices i.e. sample a random factorisation order for the sequence. This will\n # determine which tokens a given token can attend to (encoded in `perm_mask`).\n # Note: Length of token sequence being permuted has to be less than or equal to reused sequence length\n # (see documentation for `mems`), otherwise information may leak through due to reuse. In this implementation,\n # we assume that reused length is half of sequence length and permutation length is equal to reused length.\n # This requires that the sequence length be even.\n\n # Create a linear factorisation order\n perm_index = torch.arange(labels.size(1))\n # Split this into two halves, assuming that half the sequence is reused each time\n perm_index = perm_index.reshape((-1, labels.size(1) // 2)).transpose(0, 1)\n # Permute the two halves such that they do not cross over\n perm_index = perm_index[torch.randperm(labels.size(1) // 2)]\n # Flatten this out into the desired permuted factorisation order\n perm_index = torch.flatten(perm_index.transpose(0, 1))\n # Set the permutation indices of non-masked (non-functional) tokens to the\n # smallest index (-1) so that:\n # (1) They can be seen by all other positions\n # (2) They cannot see masked positions, so there won't be information leak\n perm_index.masked_fill_(~masked_indices[i] & non_func_mask[i], -1)\n # The logic for whether the i-th token can attend on the j-th token based on the factorisation order:\n # 0 (can attend): If perm_index[i] > perm_index[j] or j is neither masked nor a functional token\n # 1 (cannot attend): If perm_index[i] <= perm_index[j] and j is either masked or a functional token\n perm_mask[i] = (\n perm_index.reshape((labels.size(1), 1)) <= perm_index.reshape((1, labels.size(1)))\n ) & masked_indices[i]\n\n return inputs.long(), perm_mask, target_mapping, labels.long()\n"}}},{"rowIdx":2087,"cells":{"function_name":{"kind":"string","value":"_search_table"},"docstring":{"kind":"string","value":"Call the search service endpoint and return matching results\nSearch service logic defined here:\nhttps://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/table.py\n\n:return: a json output containing search results array as 'results'"},"masked_code":{"kind":"string","value":"import logging\nimport json\n\nfrom http import HTTPStatus\n\nfrom typing import Any, Dict # noqa: F401\n\nfrom flask import Response, jsonify, make_response, request\nfrom flask import current_app as app\nfrom flask.blueprints import Blueprint\n\nfrom amundsen_application.log.action_log import action_logging\nfrom amundsen_application.api.utils.request_utils import get_query_param, request_search\nfrom amundsen_application.api.utils.search_utils import generate_query_json, has_filters, \\\n map_table_result, transform_filters\nfrom amundsen_application.models.user import load_user, dump_user\n\nLOGGER = logging.getLogger(__name__)\n\nREQUEST_SESSION_TIMEOUT_SEC = 3\n\nsearch_blueprint = Blueprint('search', __name__, url_prefix='/explore/api/search/v0')\n\nSEARCH_TABLE_ENDPOINT = '/search'\nSEARCH_TABLE_FILTER_ENDPOINT = '/search_table'\nSEARCH_USER_ENDPOINT = '/search_user'\n\n\n@search_blueprint.route('/table', methods=['POST'])\ndef search_table() -> Response:\n \"\"\"\n Parse the request arguments and call the helper method to execute a table search\n :return: a Response created with the results from the helper method\n \"\"\"\n try:\n request_json = request.get_json()\n\n search_term = get_query_param(request_json, 'term', '\"term\" parameter expected in request data')\n page_index = get_query_param(request_json, 'pageIndex', '\"pageIndex\" parameter expected in request data')\n\n search_type = request_json.get('searchType')\n\n transformed_filters = transform_filters(filters=request_json.get('filters', {}))\n\n results_dict = _search_table(filters=transformed_filters,\n search_term=search_term,\n page_index=page_index,\n search_type=search_type)\n return make_response(jsonify(results_dict), results_dict.get('status_code', HTTPStatus.INTERNAL_SERVER_ERROR))\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n logging.exception(message)\n return make_response(jsonify(results_dict), HTTPStatus.INTERNAL_SERVER_ERROR)\n\n\n# MASKED: _search_table function (lines 56-108)\n\n\n@search_blueprint.route('/user', methods=['GET'])\ndef search_user() -> Response:\n \"\"\"\n Parse the request arguments and call the helper method to execute a user search\n :return: a Response created with the results from the helper method\n \"\"\"\n try:\n search_term = get_query_param(request.args, 'query', 'Endpoint takes a \"query\" parameter')\n page_index = get_query_param(request.args, 'page_index', 'Endpoint takes a \"page_index\" parameter')\n search_type = request.args.get('search_type')\n\n results_dict = _search_user(search_term=search_term, page_index=page_index, search_type=search_type)\n\n return make_response(jsonify(results_dict), results_dict.get('status_code', HTTPStatus.INTERNAL_SERVER_ERROR))\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n logging.exception(message)\n return make_response(jsonify(results_dict), HTTPStatus.INTERNAL_SERVER_ERROR)\n\n\n@action_logging\ndef _search_user(*, search_term: str, page_index: int, search_type: str) -> Dict[str, Any]:\n \"\"\"\n Call the search service endpoint and return matching results\n Search service logic defined here:\n https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/user.py\n\n :return: a json output containing search results array as 'results'\n \"\"\"\n\n def _map_user_result(result: Dict) -> Dict:\n user_result = dump_user(load_user(result))\n user_result['type'] = 'user'\n return user_result\n\n users = {\n 'page_index': int(page_index),\n 'results': [],\n 'total_results': 0,\n }\n\n results_dict = {\n 'search_term': search_term,\n 'msg': 'Success',\n 'status_code': HTTPStatus.OK,\n 'users': users,\n }\n\n try:\n url = '{0}?query_term={1}&page_index={2}'.format(app.config['SEARCHSERVICE_BASE'] + SEARCH_USER_ENDPOINT,\n search_term,\n page_index)\n\n response = request_search(url=url)\n status_code = response.status_code\n\n if status_code == HTTPStatus.OK:\n results_dict['msg'] = 'Success'\n results = response.json().get('results')\n users['results'] = [_map_user_result(result) for result in results]\n users['total_results'] = response.json().get('total_results')\n else:\n message = 'Encountered error: Search request failed'\n results_dict['msg'] = message\n logging.error(message)\n\n results_dict['status_code'] = status_code\n return results_dict\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n results_dict['msg'] = message\n results_dict['status_code'] = HTTPStatus.INTERNAL_SERVER_ERROR\n logging.exception(message)\n return results_dict\n\n\n# TODO - Implement\ndef _search_dashboard(*, search_term: str, page_index: int, filters: Dict, search_type: str) -> Dict[str, Any]:\n return {}"},"implementation":{"kind":"string","value":"@action_logging\ndef _search_table(*, search_term: str, page_index: int, filters: Dict, search_type: str) -> Dict[str, Any]:\n \"\"\"\n Call the search service endpoint and return matching results\n Search service logic defined here:\n https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/table.py\n\n :return: a json output containing search results array as 'results'\n \"\"\"\n # Default results\n tables = {\n 'page_index': int(page_index),\n 'results': [],\n 'total_results': 0,\n }\n\n results_dict = {\n 'search_term': search_term,\n 'msg': '',\n 'tables': tables,\n }\n\n try:\n if has_filters(filters=filters):\n query_json = generate_query_json(filters=filters, page_index=page_index, search_term=search_term)\n url_base = app.config['SEARCHSERVICE_BASE'] + SEARCH_TABLE_FILTER_ENDPOINT\n response = request_search(url=url_base,\n headers={'Content-Type': 'application/json'},\n method='POST',\n data=json.dumps(query_json))\n else:\n url_base = app.config['SEARCHSERVICE_BASE'] + SEARCH_TABLE_ENDPOINT\n url = f'{url_base}?query_term={search_term}&page_index={page_index}'\n response = request_search(url=url)\n\n status_code = response.status_code\n if status_code == HTTPStatus.OK:\n results_dict['msg'] = 'Success'\n results = response.json().get('results')\n tables['results'] = [map_table_result(result) for result in results]\n tables['total_results'] = response.json().get('total_results')\n else:\n message = 'Encountered error: Search request failed'\n results_dict['msg'] = message\n logging.error(message)\n\n results_dict['status_code'] = status_code\n return results_dict\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n results_dict['msg'] = message\n logging.exception(message)\n return results_dict"},"start_line":{"kind":"number","value":56,"string":"56"},"end_line":{"kind":"number","value":108,"string":"108"},"file_content":{"kind":"string","value":"import logging\nimport json\n\nfrom http import HTTPStatus\n\nfrom typing import Any, Dict # noqa: F401\n\nfrom flask import Response, jsonify, make_response, request\nfrom flask import current_app as app\nfrom flask.blueprints import Blueprint\n\nfrom amundsen_application.log.action_log import action_logging\nfrom amundsen_application.api.utils.request_utils import get_query_param, request_search\nfrom amundsen_application.api.utils.search_utils import generate_query_json, has_filters, \\\n map_table_result, transform_filters\nfrom amundsen_application.models.user import load_user, dump_user\n\nLOGGER = logging.getLogger(__name__)\n\nREQUEST_SESSION_TIMEOUT_SEC = 3\n\nsearch_blueprint = Blueprint('search', __name__, url_prefix='/explore/api/search/v0')\n\nSEARCH_TABLE_ENDPOINT = '/search'\nSEARCH_TABLE_FILTER_ENDPOINT = '/search_table'\nSEARCH_USER_ENDPOINT = '/search_user'\n\n\n@search_blueprint.route('/table', methods=['POST'])\ndef search_table() -> Response:\n \"\"\"\n Parse the request arguments and call the helper method to execute a table search\n :return: a Response created with the results from the helper method\n \"\"\"\n try:\n request_json = request.get_json()\n\n search_term = get_query_param(request_json, 'term', '\"term\" parameter expected in request data')\n page_index = get_query_param(request_json, 'pageIndex', '\"pageIndex\" parameter expected in request data')\n\n search_type = request_json.get('searchType')\n\n transformed_filters = transform_filters(filters=request_json.get('filters', {}))\n\n results_dict = _search_table(filters=transformed_filters,\n search_term=search_term,\n page_index=page_index,\n search_type=search_type)\n return make_response(jsonify(results_dict), results_dict.get('status_code', HTTPStatus.INTERNAL_SERVER_ERROR))\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n logging.exception(message)\n return make_response(jsonify(results_dict), HTTPStatus.INTERNAL_SERVER_ERROR)\n\n\n@action_logging\ndef _search_table(*, search_term: str, page_index: int, filters: Dict, search_type: str) -> Dict[str, Any]:\n \"\"\"\n Call the search service endpoint and return matching results\n Search service logic defined here:\n https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/table.py\n\n :return: a json output containing search results array as 'results'\n \"\"\"\n # Default results\n tables = {\n 'page_index': int(page_index),\n 'results': [],\n 'total_results': 0,\n }\n\n results_dict = {\n 'search_term': search_term,\n 'msg': '',\n 'tables': tables,\n }\n\n try:\n if has_filters(filters=filters):\n query_json = generate_query_json(filters=filters, page_index=page_index, search_term=search_term)\n url_base = app.config['SEARCHSERVICE_BASE'] + SEARCH_TABLE_FILTER_ENDPOINT\n response = request_search(url=url_base,\n headers={'Content-Type': 'application/json'},\n method='POST',\n data=json.dumps(query_json))\n else:\n url_base = app.config['SEARCHSERVICE_BASE'] + SEARCH_TABLE_ENDPOINT\n url = f'{url_base}?query_term={search_term}&page_index={page_index}'\n response = request_search(url=url)\n\n status_code = response.status_code\n if status_code == HTTPStatus.OK:\n results_dict['msg'] = 'Success'\n results = response.json().get('results')\n tables['results'] = [map_table_result(result) for result in results]\n tables['total_results'] = response.json().get('total_results')\n else:\n message = 'Encountered error: Search request failed'\n results_dict['msg'] = message\n logging.error(message)\n\n results_dict['status_code'] = status_code\n return results_dict\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n results_dict['msg'] = message\n logging.exception(message)\n return results_dict\n\n\n@search_blueprint.route('/user', methods=['GET'])\ndef search_user() -> Response:\n \"\"\"\n Parse the request arguments and call the helper method to execute a user search\n :return: a Response created with the results from the helper method\n \"\"\"\n try:\n search_term = get_query_param(request.args, 'query', 'Endpoint takes a \"query\" parameter')\n page_index = get_query_param(request.args, 'page_index', 'Endpoint takes a \"page_index\" parameter')\n search_type = request.args.get('search_type')\n\n results_dict = _search_user(search_term=search_term, page_index=page_index, search_type=search_type)\n\n return make_response(jsonify(results_dict), results_dict.get('status_code', HTTPStatus.INTERNAL_SERVER_ERROR))\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n logging.exception(message)\n return make_response(jsonify(results_dict), HTTPStatus.INTERNAL_SERVER_ERROR)\n\n\n@action_logging\ndef _search_user(*, search_term: str, page_index: int, search_type: str) -> Dict[str, Any]:\n \"\"\"\n Call the search service endpoint and return matching results\n Search service logic defined here:\n https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/user.py\n\n :return: a json output containing search results array as 'results'\n \"\"\"\n\n def _map_user_result(result: Dict) -> Dict:\n user_result = dump_user(load_user(result))\n user_result['type'] = 'user'\n return user_result\n\n users = {\n 'page_index': int(page_index),\n 'results': [],\n 'total_results': 0,\n }\n\n results_dict = {\n 'search_term': search_term,\n 'msg': 'Success',\n 'status_code': HTTPStatus.OK,\n 'users': users,\n }\n\n try:\n url = '{0}?query_term={1}&page_index={2}'.format(app.config['SEARCHSERVICE_BASE'] + SEARCH_USER_ENDPOINT,\n search_term,\n page_index)\n\n response = request_search(url=url)\n status_code = response.status_code\n\n if status_code == HTTPStatus.OK:\n results_dict['msg'] = 'Success'\n results = response.json().get('results')\n users['results'] = [_map_user_result(result) for result in results]\n users['total_results'] = response.json().get('total_results')\n else:\n message = 'Encountered error: Search request failed'\n results_dict['msg'] = message\n logging.error(message)\n\n results_dict['status_code'] = status_code\n return results_dict\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n results_dict['msg'] = message\n results_dict['status_code'] = HTTPStatus.INTERNAL_SERVER_ERROR\n logging.exception(message)\n return results_dict\n\n\n# TODO - Implement\ndef _search_dashboard(*, search_term: str, page_index: int, filters: Dict, search_type: str) -> Dict[str, Any]:\n return {}\n"}}},{"rowIdx":2088,"cells":{"function_name":{"kind":"string","value":"_search_user"},"docstring":{"kind":"string","value":"Call the search service endpoint and return matching results\nSearch service logic defined here:\nhttps://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/user.py\n\n:return: a json output containing search results array as 'results'"},"masked_code":{"kind":"string","value":"import logging\nimport json\n\nfrom http import HTTPStatus\n\nfrom typing import Any, Dict # noqa: F401\n\nfrom flask import Response, jsonify, make_response, request\nfrom flask import current_app as app\nfrom flask.blueprints import Blueprint\n\nfrom amundsen_application.log.action_log import action_logging\nfrom amundsen_application.api.utils.request_utils import get_query_param, request_search\nfrom amundsen_application.api.utils.search_utils import generate_query_json, has_filters, \\\n map_table_result, transform_filters\nfrom amundsen_application.models.user import load_user, dump_user\n\nLOGGER = logging.getLogger(__name__)\n\nREQUEST_SESSION_TIMEOUT_SEC = 3\n\nsearch_blueprint = Blueprint('search', __name__, url_prefix='/explore/api/search/v0')\n\nSEARCH_TABLE_ENDPOINT = '/search'\nSEARCH_TABLE_FILTER_ENDPOINT = '/search_table'\nSEARCH_USER_ENDPOINT = '/search_user'\n\n\n@search_blueprint.route('/table', methods=['POST'])\ndef search_table() -> Response:\n \"\"\"\n Parse the request arguments and call the helper method to execute a table search\n :return: a Response created with the results from the helper method\n \"\"\"\n try:\n request_json = request.get_json()\n\n search_term = get_query_param(request_json, 'term', '\"term\" parameter expected in request data')\n page_index = get_query_param(request_json, 'pageIndex', '\"pageIndex\" parameter expected in request data')\n\n search_type = request_json.get('searchType')\n\n transformed_filters = transform_filters(filters=request_json.get('filters', {}))\n\n results_dict = _search_table(filters=transformed_filters,\n search_term=search_term,\n page_index=page_index,\n search_type=search_type)\n return make_response(jsonify(results_dict), results_dict.get('status_code', HTTPStatus.INTERNAL_SERVER_ERROR))\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n logging.exception(message)\n return make_response(jsonify(results_dict), HTTPStatus.INTERNAL_SERVER_ERROR)\n\n\n@action_logging\ndef _search_table(*, search_term: str, page_index: int, filters: Dict, search_type: str) -> Dict[str, Any]:\n \"\"\"\n Call the search service endpoint and return matching results\n Search service logic defined here:\n https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/table.py\n\n :return: a json output containing search results array as 'results'\n \"\"\"\n # Default results\n tables = {\n 'page_index': int(page_index),\n 'results': [],\n 'total_results': 0,\n }\n\n results_dict = {\n 'search_term': search_term,\n 'msg': '',\n 'tables': tables,\n }\n\n try:\n if has_filters(filters=filters):\n query_json = generate_query_json(filters=filters, page_index=page_index, search_term=search_term)\n url_base = app.config['SEARCHSERVICE_BASE'] + SEARCH_TABLE_FILTER_ENDPOINT\n response = request_search(url=url_base,\n headers={'Content-Type': 'application/json'},\n method='POST',\n data=json.dumps(query_json))\n else:\n url_base = app.config['SEARCHSERVICE_BASE'] + SEARCH_TABLE_ENDPOINT\n url = f'{url_base}?query_term={search_term}&page_index={page_index}'\n response = request_search(url=url)\n\n status_code = response.status_code\n if status_code == HTTPStatus.OK:\n results_dict['msg'] = 'Success'\n results = response.json().get('results')\n tables['results'] = [map_table_result(result) for result in results]\n tables['total_results'] = response.json().get('total_results')\n else:\n message = 'Encountered error: Search request failed'\n results_dict['msg'] = message\n logging.error(message)\n\n results_dict['status_code'] = status_code\n return results_dict\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n results_dict['msg'] = message\n logging.exception(message)\n return results_dict\n\n\n@search_blueprint.route('/user', methods=['GET'])\ndef search_user() -> Response:\n \"\"\"\n Parse the request arguments and call the helper method to execute a user search\n :return: a Response created with the results from the helper method\n \"\"\"\n try:\n search_term = get_query_param(request.args, 'query', 'Endpoint takes a \"query\" parameter')\n page_index = get_query_param(request.args, 'page_index', 'Endpoint takes a \"page_index\" parameter')\n search_type = request.args.get('search_type')\n\n results_dict = _search_user(search_term=search_term, page_index=page_index, search_type=search_type)\n\n return make_response(jsonify(results_dict), results_dict.get('status_code', HTTPStatus.INTERNAL_SERVER_ERROR))\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n logging.exception(message)\n return make_response(jsonify(results_dict), HTTPStatus.INTERNAL_SERVER_ERROR)\n\n\n# MASKED: _search_user function (lines 131-184)\n\n\n# TODO - Implement\ndef _search_dashboard(*, search_term: str, page_index: int, filters: Dict, search_type: str) -> Dict[str, Any]:\n return {}"},"implementation":{"kind":"string","value":"@action_logging\ndef _search_user(*, search_term: str, page_index: int, search_type: str) -> Dict[str, Any]:\n \"\"\"\n Call the search service endpoint and return matching results\n Search service logic defined here:\n https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/user.py\n\n :return: a json output containing search results array as 'results'\n \"\"\"\n\n def _map_user_result(result: Dict) -> Dict:\n user_result = dump_user(load_user(result))\n user_result['type'] = 'user'\n return user_result\n\n users = {\n 'page_index': int(page_index),\n 'results': [],\n 'total_results': 0,\n }\n\n results_dict = {\n 'search_term': search_term,\n 'msg': 'Success',\n 'status_code': HTTPStatus.OK,\n 'users': users,\n }\n\n try:\n url = '{0}?query_term={1}&page_index={2}'.format(app.config['SEARCHSERVICE_BASE'] + SEARCH_USER_ENDPOINT,\n search_term,\n page_index)\n\n response = request_search(url=url)\n status_code = response.status_code\n\n if status_code == HTTPStatus.OK:\n results_dict['msg'] = 'Success'\n results = response.json().get('results')\n users['results'] = [_map_user_result(result) for result in results]\n users['total_results'] = response.json().get('total_results')\n else:\n message = 'Encountered error: Search request failed'\n results_dict['msg'] = message\n logging.error(message)\n\n results_dict['status_code'] = status_code\n return results_dict\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n results_dict['msg'] = message\n results_dict['status_code'] = HTTPStatus.INTERNAL_SERVER_ERROR\n logging.exception(message)\n return results_dict"},"start_line":{"kind":"number","value":131,"string":"131"},"end_line":{"kind":"number","value":184,"string":"184"},"file_content":{"kind":"string","value":"import logging\nimport json\n\nfrom http import HTTPStatus\n\nfrom typing import Any, Dict # noqa: F401\n\nfrom flask import Response, jsonify, make_response, request\nfrom flask import current_app as app\nfrom flask.blueprints import Blueprint\n\nfrom amundsen_application.log.action_log import action_logging\nfrom amundsen_application.api.utils.request_utils import get_query_param, request_search\nfrom amundsen_application.api.utils.search_utils import generate_query_json, has_filters, \\\n map_table_result, transform_filters\nfrom amundsen_application.models.user import load_user, dump_user\n\nLOGGER = logging.getLogger(__name__)\n\nREQUEST_SESSION_TIMEOUT_SEC = 3\n\nsearch_blueprint = Blueprint('search', __name__, url_prefix='/explore/api/search/v0')\n\nSEARCH_TABLE_ENDPOINT = '/search'\nSEARCH_TABLE_FILTER_ENDPOINT = '/search_table'\nSEARCH_USER_ENDPOINT = '/search_user'\n\n\n@search_blueprint.route('/table', methods=['POST'])\ndef search_table() -> Response:\n \"\"\"\n Parse the request arguments and call the helper method to execute a table search\n :return: a Response created with the results from the helper method\n \"\"\"\n try:\n request_json = request.get_json()\n\n search_term = get_query_param(request_json, 'term', '\"term\" parameter expected in request data')\n page_index = get_query_param(request_json, 'pageIndex', '\"pageIndex\" parameter expected in request data')\n\n search_type = request_json.get('searchType')\n\n transformed_filters = transform_filters(filters=request_json.get('filters', {}))\n\n results_dict = _search_table(filters=transformed_filters,\n search_term=search_term,\n page_index=page_index,\n search_type=search_type)\n return make_response(jsonify(results_dict), results_dict.get('status_code', HTTPStatus.INTERNAL_SERVER_ERROR))\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n logging.exception(message)\n return make_response(jsonify(results_dict), HTTPStatus.INTERNAL_SERVER_ERROR)\n\n\n@action_logging\ndef _search_table(*, search_term: str, page_index: int, filters: Dict, search_type: str) -> Dict[str, Any]:\n \"\"\"\n Call the search service endpoint and return matching results\n Search service logic defined here:\n https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/table.py\n\n :return: a json output containing search results array as 'results'\n \"\"\"\n # Default results\n tables = {\n 'page_index': int(page_index),\n 'results': [],\n 'total_results': 0,\n }\n\n results_dict = {\n 'search_term': search_term,\n 'msg': '',\n 'tables': tables,\n }\n\n try:\n if has_filters(filters=filters):\n query_json = generate_query_json(filters=filters, page_index=page_index, search_term=search_term)\n url_base = app.config['SEARCHSERVICE_BASE'] + SEARCH_TABLE_FILTER_ENDPOINT\n response = request_search(url=url_base,\n headers={'Content-Type': 'application/json'},\n method='POST',\n data=json.dumps(query_json))\n else:\n url_base = app.config['SEARCHSERVICE_BASE'] + SEARCH_TABLE_ENDPOINT\n url = f'{url_base}?query_term={search_term}&page_index={page_index}'\n response = request_search(url=url)\n\n status_code = response.status_code\n if status_code == HTTPStatus.OK:\n results_dict['msg'] = 'Success'\n results = response.json().get('results')\n tables['results'] = [map_table_result(result) for result in results]\n tables['total_results'] = response.json().get('total_results')\n else:\n message = 'Encountered error: Search request failed'\n results_dict['msg'] = message\n logging.error(message)\n\n results_dict['status_code'] = status_code\n return results_dict\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n results_dict['msg'] = message\n logging.exception(message)\n return results_dict\n\n\n@search_blueprint.route('/user', methods=['GET'])\ndef search_user() -> Response:\n \"\"\"\n Parse the request arguments and call the helper method to execute a user search\n :return: a Response created with the results from the helper method\n \"\"\"\n try:\n search_term = get_query_param(request.args, 'query', 'Endpoint takes a \"query\" parameter')\n page_index = get_query_param(request.args, 'page_index', 'Endpoint takes a \"page_index\" parameter')\n search_type = request.args.get('search_type')\n\n results_dict = _search_user(search_term=search_term, page_index=page_index, search_type=search_type)\n\n return make_response(jsonify(results_dict), results_dict.get('status_code', HTTPStatus.INTERNAL_SERVER_ERROR))\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n logging.exception(message)\n return make_response(jsonify(results_dict), HTTPStatus.INTERNAL_SERVER_ERROR)\n\n\n@action_logging\ndef _search_user(*, search_term: str, page_index: int, search_type: str) -> Dict[str, Any]:\n \"\"\"\n Call the search service endpoint and return matching results\n Search service logic defined here:\n https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/user.py\n\n :return: a json output containing search results array as 'results'\n \"\"\"\n\n def _map_user_result(result: Dict) -> Dict:\n user_result = dump_user(load_user(result))\n user_result['type'] = 'user'\n return user_result\n\n users = {\n 'page_index': int(page_index),\n 'results': [],\n 'total_results': 0,\n }\n\n results_dict = {\n 'search_term': search_term,\n 'msg': 'Success',\n 'status_code': HTTPStatus.OK,\n 'users': users,\n }\n\n try:\n url = '{0}?query_term={1}&page_index={2}'.format(app.config['SEARCHSERVICE_BASE'] + SEARCH_USER_ENDPOINT,\n search_term,\n page_index)\n\n response = request_search(url=url)\n status_code = response.status_code\n\n if status_code == HTTPStatus.OK:\n results_dict['msg'] = 'Success'\n results = response.json().get('results')\n users['results'] = [_map_user_result(result) for result in results]\n users['total_results'] = response.json().get('total_results')\n else:\n message = 'Encountered error: Search request failed'\n results_dict['msg'] = message\n logging.error(message)\n\n results_dict['status_code'] = status_code\n return results_dict\n except Exception as e:\n message = 'Encountered exception: ' + str(e)\n results_dict['msg'] = message\n results_dict['status_code'] = HTTPStatus.INTERNAL_SERVER_ERROR\n logging.exception(message)\n return results_dict\n\n\n# TODO - Implement\ndef _search_dashboard(*, search_term: str, page_index: int, filters: Dict, search_type: str) -> Dict[str, Any]:\n return {}\n"}}},{"rowIdx":2089,"cells":{"function_name":{"kind":"string","value":"start"},"docstring":{"kind":"string","value":"Start the background coroutine to balance the tasks on the cluster.\nIdempotent.\nThe scheduler argument is ignored. It is merely required to satisify the\nplugin interface. Since this class is simultaneouly an extension, the\nscheudler instance is already registered during initialization"},"masked_code":{"kind":"string","value":"from __future__ import annotations\n\nimport asyncio\nimport logging\nfrom collections import defaultdict, deque\nfrom math import log2\nfrom time import time\nfrom typing import Container\n\nfrom tlz import topk\nfrom tornado.ioloop import PeriodicCallback\n\nimport dask\nfrom dask.utils import parse_timedelta\n\nfrom .comm.addressing import get_address_host\nfrom .core import CommClosedError\nfrom .diagnostics.plugin import SchedulerPlugin\nfrom .utils import log_errors, recursive_to_dict\n\n# Stealing requires multiple network bounces and if successful also task\n# submission which may include code serialization. Therefore, be very\n# conservative in the latency estimation to suppress too aggressive stealing\n# of small tasks\nLATENCY = 0.1\n\nlogger = logging.getLogger(__name__)\n\n\nLOG_PDB = dask.config.get(\"distributed.admin.pdb-on-err\")\n\n_WORKER_STATE_CONFIRM = {\n \"ready\",\n \"constrained\",\n \"waiting\",\n}\n\n_WORKER_STATE_REJECT = {\n \"memory\",\n \"executing\",\n \"long-running\",\n \"cancelled\",\n \"resumed\",\n}\n_WORKER_STATE_UNDEFINED = {\n \"released\",\n None,\n}\n\n\nclass WorkStealing(SchedulerPlugin):\n def __init__(self, scheduler):\n self.scheduler = scheduler\n # { level: { task states } }\n self.stealable_all = [set() for i in range(15)]\n # { worker: { level: { task states } } }\n self.stealable = dict()\n # { task state: (worker, level) }\n self.key_stealable = dict()\n\n self.cost_multipliers = [1 + 2 ** (i - 6) for i in range(15)]\n self.cost_multipliers[0] = 1\n\n for worker in scheduler.workers:\n self.add_worker(worker=worker)\n\n self._callback_time = parse_timedelta(\n dask.config.get(\"distributed.scheduler.work-stealing-interval\"),\n default=\"ms\",\n )\n # `callback_time` is in milliseconds\n self.scheduler.add_plugin(self)\n self.scheduler.extensions[\"stealing\"] = self\n self.scheduler.events[\"stealing\"] = deque(maxlen=100000)\n self.count = 0\n # { task state: <stealing info dict> }\n self.in_flight = dict()\n # { worker state: occupancy }\n self.in_flight_occupancy = defaultdict(lambda: 0)\n self._in_flight_event = asyncio.Event()\n\n self.scheduler.stream_handlers[\"steal-response\"] = self.move_task_confirm\n\n# MASKED: start function (lines 84-98)\n\n async def stop(self):\n \"\"\"Stop the background task balancing tasks on the cluster.\n This will block until all currently running stealing requests are\n finished. Idempotent\n \"\"\"\n pc = self.scheduler.periodic_callbacks.pop(\"stealing\", None)\n if pc:\n pc.stop()\n await self._in_flight_event.wait()\n\n def _to_dict(self, *, exclude: Container[str] = ()) -> dict:\n \"\"\"\n A very verbose dictionary representation for debugging purposes.\n Not type stable and not inteded for roundtrips.\n\n Parameters\n ----------\n comm:\n exclude:\n A list of attributes which must not be present in the output.\n\n See also\n --------\n Client.dump_cluster_state\n \"\"\"\n return recursive_to_dict(\n {\n \"stealable_all\": self.stealable_all,\n \"stealable\": self.stealable,\n \"key_stealable\": self.key_stealable,\n \"in_flight\": self.in_flight,\n \"in_flight_occupancy\": self.in_flight_occupancy,\n },\n exclude=exclude,\n )\n\n def log(self, msg):\n return self.scheduler.log_event(\"stealing\", msg)\n\n def add_worker(self, scheduler=None, worker=None):\n self.stealable[worker] = [set() for i in range(15)]\n\n def remove_worker(self, scheduler=None, worker=None):\n del self.stealable[worker]\n\n def teardown(self):\n pcs = self.scheduler.periodic_callbacks\n if \"stealing\" in pcs:\n pcs[\"stealing\"].stop()\n del pcs[\"stealing\"]\n\n def transition(\n self, key, start, finish, compute_start=None, compute_stop=None, *args, **kwargs\n ):\n if finish == \"processing\":\n ts = self.scheduler.tasks[key]\n self.put_key_in_stealable(ts)\n elif start == \"processing\":\n ts = self.scheduler.tasks[key]\n self.remove_key_from_stealable(ts)\n d = self.in_flight.pop(ts, None)\n if d:\n thief = d[\"thief\"]\n victim = d[\"victim\"]\n self.in_flight_occupancy[thief] -= d[\"thief_duration\"]\n self.in_flight_occupancy[victim] += d[\"victim_duration\"]\n if not self.in_flight:\n self.in_flight_occupancy.clear()\n self._in_flight_event.set()\n\n def recalculate_cost(self, ts):\n if ts not in self.in_flight:\n self.remove_key_from_stealable(ts)\n self.put_key_in_stealable(ts)\n\n def put_key_in_stealable(self, ts):\n cost_multiplier, level = self.steal_time_ratio(ts)\n if cost_multiplier is not None:\n ws = ts.processing_on\n worker = ws.address\n self.stealable_all[level].add(ts)\n self.stealable[worker][level].add(ts)\n self.key_stealable[ts] = (worker, level)\n\n def remove_key_from_stealable(self, ts):\n result = self.key_stealable.pop(ts, None)\n if result is None:\n return\n\n worker, level = result\n try:\n self.stealable[worker][level].remove(ts)\n except KeyError:\n pass\n try:\n self.stealable_all[level].remove(ts)\n except KeyError:\n pass\n\n def steal_time_ratio(self, ts):\n \"\"\"The compute to communication time ratio of a key\n\n Returns\n -------\n cost_multiplier: The increased cost from moving this task as a factor.\n For example a result of zero implies a task without dependencies.\n level: The location within a stealable list to place this value\n \"\"\"\n split = ts.prefix.name\n if split in fast_tasks:\n return None, None\n\n if not ts.dependencies: # no dependencies fast path\n return 0, 0\n\n ws = ts.processing_on\n compute_time = ws.processing[ts]\n if compute_time < 0.005: # 5ms, just give up\n return None, None\n\n nbytes = ts.get_nbytes_deps()\n transfer_time = nbytes / self.scheduler.bandwidth + LATENCY\n cost_multiplier = transfer_time / compute_time\n if cost_multiplier > 100:\n return None, None\n\n level = int(round(log2(cost_multiplier) + 6))\n if level < 1:\n level = 1\n\n return cost_multiplier, level\n\n def move_task_request(self, ts, victim, thief) -> str:\n try:\n if ts in self.in_flight:\n return \"in-flight\"\n stimulus_id = f\"steal-{time()}\"\n\n key = ts.key\n self.remove_key_from_stealable(ts)\n logger.debug(\n \"Request move %s, %s: %2f -> %s: %2f\",\n key,\n victim,\n victim.occupancy,\n thief,\n thief.occupancy,\n )\n\n victim_duration = victim.processing[ts]\n\n thief_duration = self.scheduler.get_task_duration(\n ts\n ) + self.scheduler.get_comm_cost(ts, thief)\n\n self.scheduler.stream_comms[victim.address].send(\n {\"op\": \"steal-request\", \"key\": key, \"stimulus_id\": stimulus_id}\n )\n self.in_flight[ts] = {\n \"victim\": victim, # guaranteed to be processing_on\n \"thief\": thief,\n \"victim_duration\": victim_duration,\n \"thief_duration\": thief_duration,\n \"stimulus_id\": stimulus_id,\n }\n self._in_flight_event.clear()\n\n self.in_flight_occupancy[victim] -= victim_duration\n self.in_flight_occupancy[thief] += thief_duration\n return stimulus_id\n except CommClosedError:\n logger.info(\"Worker comm %r closed while stealing: %r\", victim, ts)\n return \"comm-closed\"\n except Exception as e:\n logger.exception(e)\n if LOG_PDB:\n import pdb\n\n pdb.set_trace()\n raise\n\n async def move_task_confirm(self, *, key, state, stimulus_id, worker=None):\n try:\n ts = self.scheduler.tasks[key]\n except KeyError:\n logger.debug(\"Key released between request and confirm: %s\", key)\n return\n try:\n d = self.in_flight.pop(ts)\n if d[\"stimulus_id\"] != stimulus_id:\n self.log((\"stale-response\", key, state, worker, stimulus_id))\n self.in_flight[ts] = d\n return\n except KeyError:\n self.log((\"already-aborted\", key, state, stimulus_id))\n return\n\n thief = d[\"thief\"]\n victim = d[\"victim\"]\n\n logger.debug(\"Confirm move %s, %s -> %s. State: %s\", key, victim, thief, state)\n\n self.in_flight_occupancy[thief] -= d[\"thief_duration\"]\n self.in_flight_occupancy[victim] += d[\"victim_duration\"]\n\n if not self.in_flight:\n self.in_flight_occupancy.clear()\n self._in_flight_event.set()\n\n if self.scheduler.validate:\n assert ts.processing_on == victim\n\n try:\n _log_msg = [key, state, victim.address, thief.address, stimulus_id]\n\n if ts.state != \"processing\":\n self.log((\"not-processing\", *_log_msg))\n old_thief = thief.occupancy\n new_thief = sum(thief.processing.values())\n old_victim = victim.occupancy\n new_victim = sum(victim.processing.values())\n thief.occupancy = new_thief\n victim.occupancy = new_victim\n self.scheduler.total_occupancy += (\n new_thief - old_thief + new_victim - old_victim\n )\n elif (\n state in _WORKER_STATE_UNDEFINED\n or state in _WORKER_STATE_CONFIRM\n and thief.address not in self.scheduler.workers\n ):\n self.log(\n (\n \"reschedule\",\n thief.address not in self.scheduler.workers,\n *_log_msg,\n )\n )\n self.scheduler.reschedule(key)\n # Victim had already started execution\n elif state in _WORKER_STATE_REJECT:\n self.log((\"already-computing\", *_log_msg))\n # Victim was waiting, has given up task, enact steal\n elif state in _WORKER_STATE_CONFIRM:\n self.remove_key_from_stealable(ts)\n ts.processing_on = thief\n duration = victim.processing.pop(ts)\n victim.occupancy -= duration\n self.scheduler.total_occupancy -= duration\n if not victim.processing:\n self.scheduler.total_occupancy -= victim.occupancy\n victim.occupancy = 0\n thief.processing[ts] = d[\"thief_duration\"]\n thief.occupancy += d[\"thief_duration\"]\n self.scheduler.total_occupancy += d[\"thief_duration\"]\n self.put_key_in_stealable(ts)\n\n self.scheduler.send_task_to_worker(thief.address, ts)\n self.log((\"confirm\", *_log_msg))\n else:\n raise ValueError(f\"Unexpected task state: {state}\")\n except Exception as e:\n logger.exception(e)\n if LOG_PDB:\n import pdb\n\n pdb.set_trace()\n raise\n finally:\n self.scheduler.check_idle_saturated(thief)\n self.scheduler.check_idle_saturated(victim)\n\n def balance(self):\n s = self.scheduler\n\n def combined_occupancy(ws):\n return ws.occupancy + self.in_flight_occupancy[ws]\n\n def maybe_move_task(level, ts, sat, idl, duration, cost_multiplier):\n occ_idl = combined_occupancy(idl)\n occ_sat = combined_occupancy(sat)\n\n if occ_idl + cost_multiplier * duration <= occ_sat - duration / 2:\n self.move_task_request(ts, sat, idl)\n log.append(\n (\n start,\n level,\n ts.key,\n duration,\n sat.address,\n occ_sat,\n idl.address,\n occ_idl,\n )\n )\n s.check_idle_saturated(sat, occ=occ_sat)\n s.check_idle_saturated(idl, occ=occ_idl)\n\n with log_errors():\n i = 0\n idle = s.idle.values()\n saturated = s.saturated\n if not idle or len(idle) == len(s.workers):\n return\n\n log = []\n start = time()\n\n if not s.saturated:\n saturated = topk(10, s.workers.values(), key=combined_occupancy)\n saturated = [\n ws\n for ws in saturated\n if combined_occupancy(ws) > 0.2 and len(ws.processing) > ws.nthreads\n ]\n elif len(s.saturated) < 20:\n saturated = sorted(saturated, key=combined_occupancy, reverse=True)\n if len(idle) < 20:\n idle = sorted(idle, key=combined_occupancy)\n\n for level, cost_multiplier in enumerate(self.cost_multipliers):\n if not idle:\n break\n for sat in list(saturated):\n stealable = self.stealable[sat.address][level]\n if not stealable or not idle:\n continue\n\n for ts in list(stealable):\n if ts not in self.key_stealable or ts.processing_on is not sat:\n stealable.discard(ts)\n continue\n i += 1\n if not idle:\n break\n\n if _has_restrictions(ts):\n thieves = [ws for ws in idle if _can_steal(ws, ts, sat)]\n else:\n thieves = idle\n if not thieves:\n break\n thief = thieves[i % len(thieves)]\n\n duration = sat.processing.get(ts)\n if duration is None:\n stealable.discard(ts)\n continue\n\n maybe_move_task(\n level, ts, sat, thief, duration, cost_multiplier\n )\n\n if self.cost_multipliers[level] < 20: # don't steal from public at cost\n stealable = self.stealable_all[level]\n for ts in list(stealable):\n if not idle:\n break\n if ts not in self.key_stealable:\n stealable.discard(ts)\n continue\n\n sat = ts.processing_on\n if sat is None:\n stealable.discard(ts)\n continue\n if combined_occupancy(sat) < 0.2:\n continue\n if len(sat.processing) <= sat.nthreads:\n continue\n\n i += 1\n if _has_restrictions(ts):\n thieves = [ws for ws in idle if _can_steal(ws, ts, sat)]\n else:\n thieves = idle\n if not thieves:\n continue\n thief = thieves[i % len(thieves)]\n duration = sat.processing[ts]\n\n maybe_move_task(\n level, ts, sat, thief, duration, cost_multiplier\n )\n\n if log:\n self.log(log)\n self.count += 1\n stop = time()\n if s.digests:\n s.digests[\"steal-duration\"].add(stop - start)\n\n def restart(self, scheduler):\n for stealable in self.stealable.values():\n for s in stealable:\n s.clear()\n\n for s in self.stealable_all:\n s.clear()\n self.key_stealable.clear()\n\n def story(self, *keys):\n keys = {key.key if not isinstance(key, str) else key for key in keys}\n out = []\n for _, L in self.scheduler.get_events(topic=\"stealing\"):\n if not isinstance(L, list):\n L = [L]\n for t in L:\n if any(x in keys for x in t):\n out.append(t)\n return out\n\n\ndef _has_restrictions(ts):\n \"\"\"Determine whether the given task has restrictions and whether these\n restrictions are strict.\n \"\"\"\n return not ts.loose_restrictions and (\n ts.host_restrictions or ts.worker_restrictions or ts.resource_restrictions\n )\n\n\ndef _can_steal(thief, ts, victim):\n \"\"\"Determine whether worker ``thief`` can steal task ``ts`` from worker\n ``victim``.\n\n Assumes that `ts` has some restrictions.\n \"\"\"\n if (\n ts.host_restrictions\n and get_address_host(thief.address) not in ts.host_restrictions\n ):\n return False\n elif ts.worker_restrictions and thief.address not in ts.worker_restrictions:\n return False\n\n if victim.resources is None:\n return True\n\n for resource, value in victim.resources.items():\n try:\n supplied = thief.resources[resource]\n except KeyError:\n return False\n else:\n if supplied < value:\n return False\n return True\n\n\nfast_tasks = {\"split-shuffle\"}"},"implementation":{"kind":"string","value":" async def start(self, scheduler=None):\n \"\"\"Start the background coroutine to balance the tasks on the cluster.\n Idempotent.\n The scheduler argument is ignored. It is merely required to satisify the\n plugin interface. Since this class is simultaneouly an extension, the\n scheudler instance is already registered during initialization\n \"\"\"\n if \"stealing\" in self.scheduler.periodic_callbacks:\n return\n pc = PeriodicCallback(\n callback=self.balance, callback_time=self._callback_time * 1000\n )\n pc.start()\n self.scheduler.periodic_callbacks[\"stealing\"] = pc\n self._in_flight_event.set()"},"start_line":{"kind":"number","value":84,"string":"84"},"end_line":{"kind":"number","value":98,"string":"98"},"file_content":{"kind":"string","value":"from __future__ import annotations\n\nimport asyncio\nimport logging\nfrom collections import defaultdict, deque\nfrom math import log2\nfrom time import time\nfrom typing import Container\n\nfrom tlz import topk\nfrom tornado.ioloop import PeriodicCallback\n\nimport dask\nfrom dask.utils import parse_timedelta\n\nfrom .comm.addressing import get_address_host\nfrom .core import CommClosedError\nfrom .diagnostics.plugin import SchedulerPlugin\nfrom .utils import log_errors, recursive_to_dict\n\n# Stealing requires multiple network bounces and if successful also task\n# submission which may include code serialization. Therefore, be very\n# conservative in the latency estimation to suppress too aggressive stealing\n# of small tasks\nLATENCY = 0.1\n\nlogger = logging.getLogger(__name__)\n\n\nLOG_PDB = dask.config.get(\"distributed.admin.pdb-on-err\")\n\n_WORKER_STATE_CONFIRM = {\n \"ready\",\n \"constrained\",\n \"waiting\",\n}\n\n_WORKER_STATE_REJECT = {\n \"memory\",\n \"executing\",\n \"long-running\",\n \"cancelled\",\n \"resumed\",\n}\n_WORKER_STATE_UNDEFINED = {\n \"released\",\n None,\n}\n\n\nclass WorkStealing(SchedulerPlugin):\n def __init__(self, scheduler):\n self.scheduler = scheduler\n # { level: { task states } }\n self.stealable_all = [set() for i in range(15)]\n # { worker: { level: { task states } } }\n self.stealable = dict()\n # { task state: (worker, level) }\n self.key_stealable = dict()\n\n self.cost_multipliers = [1 + 2 ** (i - 6) for i in range(15)]\n self.cost_multipliers[0] = 1\n\n for worker in scheduler.workers:\n self.add_worker(worker=worker)\n\n self._callback_time = parse_timedelta(\n dask.config.get(\"distributed.scheduler.work-stealing-interval\"),\n default=\"ms\",\n )\n # `callback_time` is in milliseconds\n self.scheduler.add_plugin(self)\n self.scheduler.extensions[\"stealing\"] = self\n self.scheduler.events[\"stealing\"] = deque(maxlen=100000)\n self.count = 0\n # { task state: <stealing info dict> }\n self.in_flight = dict()\n # { worker state: occupancy }\n self.in_flight_occupancy = defaultdict(lambda: 0)\n self._in_flight_event = asyncio.Event()\n\n self.scheduler.stream_handlers[\"steal-response\"] = self.move_task_confirm\n\n async def start(self, scheduler=None):\n \"\"\"Start the background coroutine to balance the tasks on the cluster.\n Idempotent.\n The scheduler argument is ignored. It is merely required to satisify the\n plugin interface. Since this class is simultaneouly an extension, the\n scheudler instance is already registered during initialization\n \"\"\"\n if \"stealing\" in self.scheduler.periodic_callbacks:\n return\n pc = PeriodicCallback(\n callback=self.balance, callback_time=self._callback_time * 1000\n )\n pc.start()\n self.scheduler.periodic_callbacks[\"stealing\"] = pc\n self._in_flight_event.set()\n\n async def stop(self):\n \"\"\"Stop the background task balancing tasks on the cluster.\n This will block until all currently running stealing requests are\n finished. Idempotent\n \"\"\"\n pc = self.scheduler.periodic_callbacks.pop(\"stealing\", None)\n if pc:\n pc.stop()\n await self._in_flight_event.wait()\n\n def _to_dict(self, *, exclude: Container[str] = ()) -> dict:\n \"\"\"\n A very verbose dictionary representation for debugging purposes.\n Not type stable and not inteded for roundtrips.\n\n Parameters\n ----------\n comm:\n exclude:\n A list of attributes which must not be present in the output.\n\n See also\n --------\n Client.dump_cluster_state\n \"\"\"\n return recursive_to_dict(\n {\n \"stealable_all\": self.stealable_all,\n \"stealable\": self.stealable,\n \"key_stealable\": self.key_stealable,\n \"in_flight\": self.in_flight,\n \"in_flight_occupancy\": self.in_flight_occupancy,\n },\n exclude=exclude,\n )\n\n def log(self, msg):\n return self.scheduler.log_event(\"stealing\", msg)\n\n def add_worker(self, scheduler=None, worker=None):\n self.stealable[worker] = [set() for i in range(15)]\n\n def remove_worker(self, scheduler=None, worker=None):\n del self.stealable[worker]\n\n def teardown(self):\n pcs = self.scheduler.periodic_callbacks\n if \"stealing\" in pcs:\n pcs[\"stealing\"].stop()\n del pcs[\"stealing\"]\n\n def transition(\n self, key, start, finish, compute_start=None, compute_stop=None, *args, **kwargs\n ):\n if finish == \"processing\":\n ts = self.scheduler.tasks[key]\n self.put_key_in_stealable(ts)\n elif start == \"processing\":\n ts = self.scheduler.tasks[key]\n self.remove_key_from_stealable(ts)\n d = self.in_flight.pop(ts, None)\n if d:\n thief = d[\"thief\"]\n victim = d[\"victim\"]\n self.in_flight_occupancy[thief] -= d[\"thief_duration\"]\n self.in_flight_occupancy[victim] += d[\"victim_duration\"]\n if not self.in_flight:\n self.in_flight_occupancy.clear()\n self._in_flight_event.set()\n\n def recalculate_cost(self, ts):\n if ts not in self.in_flight:\n self.remove_key_from_stealable(ts)\n self.put_key_in_stealable(ts)\n\n def put_key_in_stealable(self, ts):\n cost_multiplier, level = self.steal_time_ratio(ts)\n if cost_multiplier is not None:\n ws = ts.processing_on\n worker = ws.address\n self.stealable_all[level].add(ts)\n self.stealable[worker][level].add(ts)\n self.key_stealable[ts] = (worker, level)\n\n def remove_key_from_stealable(self, ts):\n result = self.key_stealable.pop(ts, None)\n if result is None:\n return\n\n worker, level = result\n try:\n self.stealable[worker][level].remove(ts)\n except KeyError:\n pass\n try:\n self.stealable_all[level].remove(ts)\n except KeyError:\n pass\n\n def steal_time_ratio(self, ts):\n \"\"\"The compute to communication time ratio of a key\n\n Returns\n -------\n cost_multiplier: The increased cost from moving this task as a factor.\n For example a result of zero implies a task without dependencies.\n level: The location within a stealable list to place this value\n \"\"\"\n split = ts.prefix.name\n if split in fast_tasks:\n return None, None\n\n if not ts.dependencies: # no dependencies fast path\n return 0, 0\n\n ws = ts.processing_on\n compute_time = ws.processing[ts]\n if compute_time < 0.005: # 5ms, just give up\n return None, None\n\n nbytes = ts.get_nbytes_deps()\n transfer_time = nbytes / self.scheduler.bandwidth + LATENCY\n cost_multiplier = transfer_time / compute_time\n if cost_multiplier > 100:\n return None, None\n\n level = int(round(log2(cost_multiplier) + 6))\n if level < 1:\n level = 1\n\n return cost_multiplier, level\n\n def move_task_request(self, ts, victim, thief) -> str:\n try:\n if ts in self.in_flight:\n return \"in-flight\"\n stimulus_id = f\"steal-{time()}\"\n\n key = ts.key\n self.remove_key_from_stealable(ts)\n logger.debug(\n \"Request move %s, %s: %2f -> %s: %2f\",\n key,\n victim,\n victim.occupancy,\n thief,\n thief.occupancy,\n )\n\n victim_duration = victim.processing[ts]\n\n thief_duration = self.scheduler.get_task_duration(\n ts\n ) + self.scheduler.get_comm_cost(ts, thief)\n\n self.scheduler.stream_comms[victim.address].send(\n {\"op\": \"steal-request\", \"key\": key, \"stimulus_id\": stimulus_id}\n )\n self.in_flight[ts] = {\n \"victim\": victim, # guaranteed to be processing_on\n \"thief\": thief,\n \"victim_duration\": victim_duration,\n \"thief_duration\": thief_duration,\n \"stimulus_id\": stimulus_id,\n }\n self._in_flight_event.clear()\n\n self.in_flight_occupancy[victim] -= victim_duration\n self.in_flight_occupancy[thief] += thief_duration\n return stimulus_id\n except CommClosedError:\n logger.info(\"Worker comm %r closed while stealing: %r\", victim, ts)\n return \"comm-closed\"\n except Exception as e:\n logger.exception(e)\n if LOG_PDB:\n import pdb\n\n pdb.set_trace()\n raise\n\n async def move_task_confirm(self, *, key, state, stimulus_id, worker=None):\n try:\n ts = self.scheduler.tasks[key]\n except KeyError:\n logger.debug(\"Key released between request and confirm: %s\", key)\n return\n try:\n d = self.in_flight.pop(ts)\n if d[\"stimulus_id\"] != stimulus_id:\n self.log((\"stale-response\", key, state, worker, stimulus_id))\n self.in_flight[ts] = d\n return\n except KeyError:\n self.log((\"already-aborted\", key, state, stimulus_id))\n return\n\n thief = d[\"thief\"]\n victim = d[\"victim\"]\n\n logger.debug(\"Confirm move %s, %s -> %s. State: %s\", key, victim, thief, state)\n\n self.in_flight_occupancy[thief] -= d[\"thief_duration\"]\n self.in_flight_occupancy[victim] += d[\"victim_duration\"]\n\n if not self.in_flight:\n self.in_flight_occupancy.clear()\n self._in_flight_event.set()\n\n if self.scheduler.validate:\n assert ts.processing_on == victim\n\n try:\n _log_msg = [key, state, victim.address, thief.address, stimulus_id]\n\n if ts.state != \"processing\":\n self.log((\"not-processing\", *_log_msg))\n old_thief = thief.occupancy\n new_thief = sum(thief.processing.values())\n old_victim = victim.occupancy\n new_victim = sum(victim.processing.values())\n thief.occupancy = new_thief\n victim.occupancy = new_victim\n self.scheduler.total_occupancy += (\n new_thief - old_thief + new_victim - old_victim\n )\n elif (\n state in _WORKER_STATE_UNDEFINED\n or state in _WORKER_STATE_CONFIRM\n and thief.address not in self.scheduler.workers\n ):\n self.log(\n (\n \"reschedule\",\n thief.address not in self.scheduler.workers,\n *_log_msg,\n )\n )\n self.scheduler.reschedule(key)\n # Victim had already started execution\n elif state in _WORKER_STATE_REJECT:\n self.log((\"already-computing\", *_log_msg))\n # Victim was waiting, has given up task, enact steal\n elif state in _WORKER_STATE_CONFIRM:\n self.remove_key_from_stealable(ts)\n ts.processing_on = thief\n duration = victim.processing.pop(ts)\n victim.occupancy -= duration\n self.scheduler.total_occupancy -= duration\n if not victim.processing:\n self.scheduler.total_occupancy -= victim.occupancy\n victim.occupancy = 0\n thief.processing[ts] = d[\"thief_duration\"]\n thief.occupancy += d[\"thief_duration\"]\n self.scheduler.total_occupancy += d[\"thief_duration\"]\n self.put_key_in_stealable(ts)\n\n self.scheduler.send_task_to_worker(thief.address, ts)\n self.log((\"confirm\", *_log_msg))\n else:\n raise ValueError(f\"Unexpected task state: {state}\")\n except Exception as e:\n logger.exception(e)\n if LOG_PDB:\n import pdb\n\n pdb.set_trace()\n raise\n finally:\n self.scheduler.check_idle_saturated(thief)\n self.scheduler.check_idle_saturated(victim)\n\n def balance(self):\n s = self.scheduler\n\n def combined_occupancy(ws):\n return ws.occupancy + self.in_flight_occupancy[ws]\n\n def maybe_move_task(level, ts, sat, idl, duration, cost_multiplier):\n occ_idl = combined_occupancy(idl)\n occ_sat = combined_occupancy(sat)\n\n if occ_idl + cost_multiplier * duration <= occ_sat - duration / 2:\n self.move_task_request(ts, sat, idl)\n log.append(\n (\n start,\n level,\n ts.key,\n duration,\n sat.address,\n occ_sat,\n idl.address,\n occ_idl,\n )\n )\n s.check_idle_saturated(sat, occ=occ_sat)\n s.check_idle_saturated(idl, occ=occ_idl)\n\n with log_errors():\n i = 0\n idle = s.idle.values()\n saturated = s.saturated\n if not idle or len(idle) == len(s.workers):\n return\n\n log = []\n start = time()\n\n if not s.saturated:\n saturated = topk(10, s.workers.values(), key=combined_occupancy)\n saturated = [\n ws\n for ws in saturated\n if combined_occupancy(ws) > 0.2 and len(ws.processing) > ws.nthreads\n ]\n elif len(s.saturated) < 20:\n saturated = sorted(saturated, key=combined_occupancy, reverse=True)\n if len(idle) < 20:\n idle = sorted(idle, key=combined_occupancy)\n\n for level, cost_multiplier in enumerate(self.cost_multipliers):\n if not idle:\n break\n for sat in list(saturated):\n stealable = self.stealable[sat.address][level]\n if not stealable or not idle:\n continue\n\n for ts in list(stealable):\n if ts not in self.key_stealable or ts.processing_on is not sat:\n stealable.discard(ts)\n continue\n i += 1\n if not idle:\n break\n\n if _has_restrictions(ts):\n thieves = [ws for ws in idle if _can_steal(ws, ts, sat)]\n else:\n thieves = idle\n if not thieves:\n break\n thief = thieves[i % len(thieves)]\n\n duration = sat.processing.get(ts)\n if duration is None:\n stealable.discard(ts)\n continue\n\n maybe_move_task(\n level, ts, sat, thief, duration, cost_multiplier\n )\n\n if self.cost_multipliers[level] < 20: # don't steal from public at cost\n stealable = self.stealable_all[level]\n for ts in list(stealable):\n if not idle:\n break\n if ts not in self.key_stealable:\n stealable.discard(ts)\n continue\n\n sat = ts.processing_on\n if sat is None:\n stealable.discard(ts)\n continue\n if combined_occupancy(sat) < 0.2:\n continue\n if len(sat.processing) <= sat.nthreads:\n continue\n\n i += 1\n if _has_restrictions(ts):\n thieves = [ws for ws in idle if _can_steal(ws, ts, sat)]\n else:\n thieves = idle\n if not thieves:\n continue\n thief = thieves[i % len(thieves)]\n duration = sat.processing[ts]\n\n maybe_move_task(\n level, ts, sat, thief, duration, cost_multiplier\n )\n\n if log:\n self.log(log)\n self.count += 1\n stop = time()\n if s.digests:\n s.digests[\"steal-duration\"].add(stop - start)\n\n def restart(self, scheduler):\n for stealable in self.stealable.values():\n for s in stealable:\n s.clear()\n\n for s in self.stealable_all:\n s.clear()\n self.key_stealable.clear()\n\n def story(self, *keys):\n keys = {key.key if not isinstance(key, str) else key for key in keys}\n out = []\n for _, L in self.scheduler.get_events(topic=\"stealing\"):\n if not isinstance(L, list):\n L = [L]\n for t in L:\n if any(x in keys for x in t):\n out.append(t)\n return out\n\n\ndef _has_restrictions(ts):\n \"\"\"Determine whether the given task has restrictions and whether these\n restrictions are strict.\n \"\"\"\n return not ts.loose_restrictions and (\n ts.host_restrictions or ts.worker_restrictions or ts.resource_restrictions\n )\n\n\ndef _can_steal(thief, ts, victim):\n \"\"\"Determine whether worker ``thief`` can steal task ``ts`` from worker\n ``victim``.\n\n Assumes that `ts` has some restrictions.\n \"\"\"\n if (\n ts.host_restrictions\n and get_address_host(thief.address) not in ts.host_restrictions\n ):\n return False\n elif ts.worker_restrictions and thief.address not in ts.worker_restrictions:\n return False\n\n if victim.resources is None:\n return True\n\n for resource, value in victim.resources.items():\n try:\n supplied = thief.resources[resource]\n except KeyError:\n return False\n else:\n if supplied < value:\n return False\n return True\n\n\nfast_tasks = {\"split-shuffle\"}\n"}}},{"rowIdx":2090,"cells":{"function_name":{"kind":"string","value":"is_noncomplex"},"docstring":{"kind":"string","value":"Returns True if *obj* is a special (weird) class, that is more complex\nthan primitive data types, but is not a full object. Including:\n\n * :class:`~time.struct_time`"},"masked_code":{"kind":"string","value":"# Copyright (C) 2008 John Paulett (john -at- paulett.org)\n# Copyright (C) 2009-2018 David Aguilar (davvid -at- gmail.com)\n# All rights reserved.\n#\n# This software is licensed as described in the file COPYING, which\n# you should have received as part of this distribution.\n\n\"\"\"Helper functions for pickling and unpickling. Most functions assist in\ndetermining the type of an object.\n\"\"\"\nfrom __future__ import absolute_import, division, unicode_literals\nimport base64\nimport collections\nimport io\nimport operator\nimport sys\nimport time\nimport types\nimport inspect\n\nfrom . import tags\nfrom . import compat\nfrom .compat import (\n abc_iterator,\n class_types,\n iterator_types,\n numeric_types,\n PY2,\n PY3,\n PY3_ORDERED_DICT,\n)\n\nif PY2:\n import __builtin__\n\nSEQUENCES = (list, set, tuple)\nSEQUENCES_SET = {list, set, tuple}\nPRIMITIVES = {compat.ustr, bool, type(None)} | set(numeric_types)\nNON_REDUCIBLE_TYPES = {\n int,\n float,\n list,\n dict,\n set,\n tuple,\n object,\n bytes,\n types.FunctionType,\n types.MethodType,\n types.LambdaType,\n types.BuiltinFunctionType,\n types.BuiltinMethodType,\n} | PRIMITIVES\n\n\ndef is_type(obj):\n \"\"\"Returns True is obj is a reference to a type.\n\n >>> is_type(1)\n False\n\n >>> is_type(object)\n True\n\n >>> class Klass: pass\n >>> is_type(Klass)\n True\n \"\"\"\n # use \"isinstance\" and not \"is\" to allow for metaclasses\n return isinstance(obj, class_types)\n\n\ndef has_method(obj, name):\n # false if attribute doesn't exist\n if not hasattr(obj, name):\n return False\n func = getattr(obj, name)\n\n # builtin descriptors like __getnewargs__\n if isinstance(func, types.BuiltinMethodType):\n return True\n\n # note that FunctionType has a different meaning in py2/py3\n if not isinstance(func, (types.MethodType, types.FunctionType)):\n return False\n\n # need to go through __dict__'s since in py3\n # methods are essentially descriptors\n\n # __class__ for old-style classes\n base_type = obj if is_type(obj) else obj.__class__\n original = None\n # there is no .mro() for old-style classes\n for subtype in inspect.getmro(base_type):\n original = vars(subtype).get(name)\n if original is not None:\n break\n\n # name not found in the mro\n if original is None:\n return False\n\n # static methods are always fine\n if isinstance(original, staticmethod):\n return True\n\n # at this point, the method has to be an instancemthod or a classmethod\n self_attr = '__self__' if PY3 else 'im_self'\n if not hasattr(func, self_attr):\n return False\n bound_to = getattr(func, self_attr)\n\n # class methods\n if isinstance(original, classmethod):\n return issubclass(base_type, bound_to)\n\n # bound methods\n return isinstance(obj, type(bound_to))\n\n\ndef is_object(obj):\n \"\"\"Returns True is obj is a reference to an object instance.\n\n >>> is_object(1)\n True\n\n >>> is_object(object())\n True\n\n >>> is_object(lambda x: 1)\n False\n \"\"\"\n return isinstance(obj, object) and not isinstance(\n obj, (type, types.FunctionType, types.BuiltinFunctionType)\n )\n\n\ndef is_primitive(obj):\n \"\"\"Helper method to see if the object is a basic data type. Unicode strings,\n integers, longs, floats, booleans, and None are considered primitive\n and will return True when passed into *is_primitive()*\n\n >>> is_primitive(3)\n True\n >>> is_primitive([4,4])\n False\n \"\"\"\n return type(obj) in PRIMITIVES\n\n\ndef is_enum(obj):\n \"\"\"Is the object an enum?\"\"\"\n return 'enum' in sys.modules and isinstance(obj, sys.modules['enum'].Enum)\n\n\ndef is_dictionary(obj):\n \"\"\"Helper method for testing if the object is a dictionary.\n\n >>> is_dictionary({'key':'value'})\n True\n\n \"\"\"\n return type(obj) is dict\n\n\ndef is_sequence(obj):\n \"\"\"Helper method to see if the object is a sequence (list, set, or tuple).\n\n >>> is_sequence([4])\n True\n\n \"\"\"\n return type(obj) in SEQUENCES_SET\n\n\ndef is_list(obj):\n \"\"\"Helper method to see if the object is a Python list.\n\n >>> is_list([4])\n True\n \"\"\"\n return type(obj) is list\n\n\ndef is_set(obj):\n \"\"\"Helper method to see if the object is a Python set.\n\n >>> is_set(set())\n True\n \"\"\"\n return type(obj) is set\n\n\ndef is_bytes(obj):\n \"\"\"Helper method to see if the object is a bytestring.\n\n >>> is_bytes(b'foo')\n True\n \"\"\"\n return type(obj) is bytes\n\n\ndef is_unicode(obj):\n \"\"\"Helper method to see if the object is a unicode string\"\"\"\n return type(obj) is compat.ustr\n\n\ndef is_tuple(obj):\n \"\"\"Helper method to see if the object is a Python tuple.\n\n >>> is_tuple((1,))\n True\n \"\"\"\n return type(obj) is tuple\n\n\ndef is_dictionary_subclass(obj):\n \"\"\"Returns True if *obj* is a subclass of the dict type. *obj* must be\n a subclass and not the actual builtin dict.\n\n >>> class Temp(dict): pass\n >>> is_dictionary_subclass(Temp())\n True\n \"\"\"\n # TODO: add UserDict\n return (\n hasattr(obj, '__class__')\n and issubclass(obj.__class__, dict)\n and type(obj) is not dict\n )\n\n\ndef is_sequence_subclass(obj):\n \"\"\"Returns True if *obj* is a subclass of list, set or tuple.\n\n *obj* must be a subclass and not the actual builtin, such\n as list, set, tuple, etc..\n\n >>> class Temp(list): pass\n >>> is_sequence_subclass(Temp())\n True\n \"\"\"\n return (\n hasattr(obj, '__class__')\n and (issubclass(obj.__class__, SEQUENCES) or is_list_like(obj))\n and not is_sequence(obj)\n )\n\n\n# MASKED: is_noncomplex function (lines 250-258)\n\n\ndef is_function(obj):\n \"\"\"Returns true if passed a function\n\n >>> is_function(lambda x: 1)\n True\n\n >>> is_function(locals)\n True\n\n >>> def method(): pass\n >>> is_function(method)\n True\n\n >>> is_function(1)\n False\n \"\"\"\n function_types = {\n types.FunctionType,\n types.MethodType,\n types.LambdaType,\n types.BuiltinFunctionType,\n types.BuiltinMethodType,\n }\n return type(obj) in function_types\n\n\ndef is_module_function(obj):\n \"\"\"Return True if `obj` is a module-global function\n\n >>> import os\n >>> is_module_function(os.path.exists)\n True\n\n >>> is_module_function(lambda: None)\n False\n\n \"\"\"\n\n return (\n hasattr(obj, '__class__')\n and isinstance(obj, (types.FunctionType, types.BuiltinFunctionType))\n and hasattr(obj, '__module__')\n and hasattr(obj, '__name__')\n and obj.__name__ != '<lambda>'\n )\n\n\ndef is_module(obj):\n \"\"\"Returns True if passed a module\n\n >>> import os\n >>> is_module(os)\n True\n\n \"\"\"\n return isinstance(obj, types.ModuleType)\n\n\ndef is_picklable(name, value):\n \"\"\"Return True if an object can be pickled\n\n >>> import os\n >>> is_picklable('os', os)\n True\n\n >>> def foo(): pass\n >>> is_picklable('foo', foo)\n True\n\n >>> is_picklable('foo', lambda: None)\n False\n\n \"\"\"\n if name in tags.RESERVED:\n return False\n return is_module_function(value) or not is_function(value)\n\n\ndef is_installed(module):\n \"\"\"Tests to see if ``module`` is available on the sys.path\n\n >>> is_installed('sys')\n True\n >>> is_installed('hopefullythisisnotarealmodule')\n False\n\n \"\"\"\n try:\n __import__(module)\n return True\n except ImportError:\n return False\n\n\ndef is_list_like(obj):\n return hasattr(obj, '__getitem__') and hasattr(obj, 'append')\n\n\ndef is_iterator(obj):\n is_file = PY2 and isinstance(obj, __builtin__.file)\n return (\n isinstance(obj, abc_iterator) and not isinstance(obj, io.IOBase) and not is_file\n )\n\n\ndef is_collections(obj):\n try:\n return type(obj).__module__ == 'collections'\n except Exception:\n return False\n\n\ndef is_reducible_sequence_subclass(obj):\n return hasattr(obj, '__class__') and issubclass(obj.__class__, SEQUENCES)\n\n\ndef is_reducible(obj):\n \"\"\"\n Returns false if of a type which have special casing,\n and should not have their __reduce__ methods used\n \"\"\"\n # defaultdicts may contain functions which we cannot serialise\n if is_collections(obj) and not isinstance(obj, collections.defaultdict):\n return True\n # sets are slightly slower in this case\n if type(obj) in NON_REDUCIBLE_TYPES:\n return False\n elif obj is object:\n return False\n elif is_list_like(obj):\n return False\n elif isinstance(obj, types.ModuleType):\n return False\n elif is_dictionary_subclass(obj):\n return False\n elif is_reducible_sequence_subclass(obj):\n return False\n elif isinstance(getattr(obj, '__slots__', None), iterator_types):\n return False\n elif is_type(obj) and obj.__module__ == 'datetime':\n return False\n return True\n\n\ndef in_dict(obj, key, default=False):\n \"\"\"\n Returns true if key exists in obj.__dict__; false if not in.\n If obj.__dict__ is absent, return default\n \"\"\"\n return (key in obj.__dict__) if getattr(obj, '__dict__', None) else default\n\n\ndef in_slots(obj, key, default=False):\n \"\"\"\n Returns true if key exists in obj.__slots__; false if not in.\n If obj.__slots__ is absent, return default\n \"\"\"\n return (key in obj.__slots__) if getattr(obj, '__slots__', None) else default\n\n\ndef has_reduce(obj):\n \"\"\"\n Tests if __reduce__ or __reduce_ex__ exists in the object dict or\n in the class dicts of every class in the MRO *except object*.\n\n Returns a tuple of booleans (has_reduce, has_reduce_ex)\n \"\"\"\n\n if not is_reducible(obj) or is_type(obj):\n return (False, False)\n\n # in this case, reduce works and is desired\n # notwithstanding depending on default object\n # reduce\n if is_noncomplex(obj):\n return (False, True)\n\n has_reduce = False\n has_reduce_ex = False\n\n REDUCE = '__reduce__'\n REDUCE_EX = '__reduce_ex__'\n\n # For object instance\n has_reduce = in_dict(obj, REDUCE) or in_slots(obj, REDUCE)\n has_reduce_ex = in_dict(obj, REDUCE_EX) or in_slots(obj, REDUCE_EX)\n\n # turn to the MRO\n for base in type(obj).__mro__:\n if is_reducible(base):\n has_reduce = has_reduce or in_dict(base, REDUCE)\n has_reduce_ex = has_reduce_ex or in_dict(base, REDUCE_EX)\n if has_reduce and has_reduce_ex:\n return (has_reduce, has_reduce_ex)\n\n # for things that don't have a proper dict but can be\n # getattred (rare, but includes some builtins)\n cls = type(obj)\n object_reduce = getattr(object, REDUCE)\n object_reduce_ex = getattr(object, REDUCE_EX)\n if not has_reduce:\n has_reduce_cls = getattr(cls, REDUCE, False)\n if has_reduce_cls is not object_reduce:\n has_reduce = has_reduce_cls\n\n if not has_reduce_ex:\n has_reduce_ex_cls = getattr(cls, REDUCE_EX, False)\n if has_reduce_ex_cls is not object_reduce_ex:\n has_reduce_ex = has_reduce_ex_cls\n\n return (has_reduce, has_reduce_ex)\n\n\ndef translate_module_name(module):\n \"\"\"Rename builtin modules to a consistent module name.\n\n Prefer the more modern naming.\n\n This is used so that references to Python's `builtins` module can\n be loaded in both Python 2 and 3. We remap to the \"__builtin__\"\n name and unmap it when importing.\n\n Map the Python2 `exceptions` module to `builtins` because\n `builtins` is a superset and contains everything that is\n available in `exceptions`, which makes the translation simpler.\n\n See untranslate_module_name() for the reverse operation.\n \"\"\"\n lookup = dict(__builtin__='builtins', exceptions='builtins')\n return lookup.get(module, module)\n\n\ndef untranslate_module_name(module):\n \"\"\"Rename module names mention in JSON to names that we can import\n\n This reverses the translation applied by translate_module_name() to\n a module name available to the current version of Python.\n\n \"\"\"\n module = _0_9_6_compat_untranslate(module)\n lookup = dict(builtins='__builtin__') if PY2 else {}\n return lookup.get(module, module)\n\n\ndef _0_9_6_compat_untranslate(module):\n \"\"\"Provide compatibility for pickles created with jsonpickle 0.9.6 and\n earlier, remapping `exceptions` and `__builtin__` to `builtins`.\n \"\"\"\n lookup = dict(__builtin__='builtins', exceptions='builtins')\n return lookup.get(module, module)\n\n\ndef importable_name(cls):\n \"\"\"\n >>> class Example(object):\n ... pass\n\n >>> ex = Example()\n >>> importable_name(ex.__class__) == 'jsonpickle.util.Example'\n True\n >>> importable_name(type(25)) == 'builtins.int'\n True\n >>> importable_name(None.__class__) == 'builtins.NoneType'\n True\n >>> importable_name(False.__class__) == 'builtins.bool'\n True\n >>> importable_name(AttributeError) == 'builtins.AttributeError'\n True\n\n \"\"\"\n # Use the fully-qualified name if available (Python >= 3.3)\n name = getattr(cls, '__qualname__', cls.__name__)\n module = translate_module_name(cls.__module__)\n return '{}.{}'.format(module, name)\n\n\ndef b64encode(data):\n \"\"\"\n Encode binary data to ascii text in base64. Data must be bytes.\n \"\"\"\n return base64.b64encode(data).decode('ascii')\n\n\ndef b64decode(payload):\n \"\"\"\n Decode payload - must be ascii text.\n \"\"\"\n return base64.b64decode(payload)\n\n\ndef b85encode(data):\n \"\"\"\n Encode binary data to ascii text in base85. Data must be bytes.\n \"\"\"\n if PY2:\n raise NotImplementedError(\"Python 2 can't encode data in base85.\")\n return base64.b85encode(data).decode('ascii')\n\n\ndef b85decode(payload):\n \"\"\"\n Decode payload - must be ascii text.\n \"\"\"\n if PY2:\n raise NotImplementedError(\"Python 2 can't decode base85-encoded data.\")\n return base64.b85decode(payload)\n\n\ndef itemgetter(obj, getter=operator.itemgetter(0)):\n return compat.ustr(getter(obj))\n\n\ndef items(obj):\n \"\"\"Iterate over dicts in a deterministic order\n\n Python2 does not guarantee dict ordering, so this function\n papers over the difference in behavior. Python3 does guarantee\n dict order, without use of OrderedDict, so no sorting is needed there.\n\n \"\"\"\n if PY3_ORDERED_DICT:\n for k, v in obj.items():\n yield k, v\n else:\n for k, v in sorted(obj.items(), key=itemgetter):\n yield k, v"},"implementation":{"kind":"string","value":"def is_noncomplex(obj):\n \"\"\"Returns True if *obj* is a special (weird) class, that is more complex\n than primitive data types, but is not a full object. Including:\n\n * :class:`~time.struct_time`\n \"\"\"\n if type(obj) is time.struct_time:\n return True\n return False"},"start_line":{"kind":"number","value":250,"string":"250"},"end_line":{"kind":"number","value":258,"string":"258"},"file_content":{"kind":"string","value":"# Copyright (C) 2008 John Paulett (john -at- paulett.org)\n# Copyright (C) 2009-2018 David Aguilar (davvid -at- gmail.com)\n# All rights reserved.\n#\n# This software is licensed as described in the file COPYING, which\n# you should have received as part of this distribution.\n\n\"\"\"Helper functions for pickling and unpickling. Most functions assist in\ndetermining the type of an object.\n\"\"\"\nfrom __future__ import absolute_import, division, unicode_literals\nimport base64\nimport collections\nimport io\nimport operator\nimport sys\nimport time\nimport types\nimport inspect\n\nfrom . import tags\nfrom . import compat\nfrom .compat import (\n abc_iterator,\n class_types,\n iterator_types,\n numeric_types,\n PY2,\n PY3,\n PY3_ORDERED_DICT,\n)\n\nif PY2:\n import __builtin__\n\nSEQUENCES = (list, set, tuple)\nSEQUENCES_SET = {list, set, tuple}\nPRIMITIVES = {compat.ustr, bool, type(None)} | set(numeric_types)\nNON_REDUCIBLE_TYPES = {\n int,\n float,\n list,\n dict,\n set,\n tuple,\n object,\n bytes,\n types.FunctionType,\n types.MethodType,\n types.LambdaType,\n types.BuiltinFunctionType,\n types.BuiltinMethodType,\n} | PRIMITIVES\n\n\ndef is_type(obj):\n \"\"\"Returns True is obj is a reference to a type.\n\n >>> is_type(1)\n False\n\n >>> is_type(object)\n True\n\n >>> class Klass: pass\n >>> is_type(Klass)\n True\n \"\"\"\n # use \"isinstance\" and not \"is\" to allow for metaclasses\n return isinstance(obj, class_types)\n\n\ndef has_method(obj, name):\n # false if attribute doesn't exist\n if not hasattr(obj, name):\n return False\n func = getattr(obj, name)\n\n # builtin descriptors like __getnewargs__\n if isinstance(func, types.BuiltinMethodType):\n return True\n\n # note that FunctionType has a different meaning in py2/py3\n if not isinstance(func, (types.MethodType, types.FunctionType)):\n return False\n\n # need to go through __dict__'s since in py3\n # methods are essentially descriptors\n\n # __class__ for old-style classes\n base_type = obj if is_type(obj) else obj.__class__\n original = None\n # there is no .mro() for old-style classes\n for subtype in inspect.getmro(base_type):\n original = vars(subtype).get(name)\n if original is not None:\n break\n\n # name not found in the mro\n if original is None:\n return False\n\n # static methods are always fine\n if isinstance(original, staticmethod):\n return True\n\n # at this point, the method has to be an instancemthod or a classmethod\n self_attr = '__self__' if PY3 else 'im_self'\n if not hasattr(func, self_attr):\n return False\n bound_to = getattr(func, self_attr)\n\n # class methods\n if isinstance(original, classmethod):\n return issubclass(base_type, bound_to)\n\n # bound methods\n return isinstance(obj, type(bound_to))\n\n\ndef is_object(obj):\n \"\"\"Returns True is obj is a reference to an object instance.\n\n >>> is_object(1)\n True\n\n >>> is_object(object())\n True\n\n >>> is_object(lambda x: 1)\n False\n \"\"\"\n return isinstance(obj, object) and not isinstance(\n obj, (type, types.FunctionType, types.BuiltinFunctionType)\n )\n\n\ndef is_primitive(obj):\n \"\"\"Helper method to see if the object is a basic data type. Unicode strings,\n integers, longs, floats, booleans, and None are considered primitive\n and will return True when passed into *is_primitive()*\n\n >>> is_primitive(3)\n True\n >>> is_primitive([4,4])\n False\n \"\"\"\n return type(obj) in PRIMITIVES\n\n\ndef is_enum(obj):\n \"\"\"Is the object an enum?\"\"\"\n return 'enum' in sys.modules and isinstance(obj, sys.modules['enum'].Enum)\n\n\ndef is_dictionary(obj):\n \"\"\"Helper method for testing if the object is a dictionary.\n\n >>> is_dictionary({'key':'value'})\n True\n\n \"\"\"\n return type(obj) is dict\n\n\ndef is_sequence(obj):\n \"\"\"Helper method to see if the object is a sequence (list, set, or tuple).\n\n >>> is_sequence([4])\n True\n\n \"\"\"\n return type(obj) in SEQUENCES_SET\n\n\ndef is_list(obj):\n \"\"\"Helper method to see if the object is a Python list.\n\n >>> is_list([4])\n True\n \"\"\"\n return type(obj) is list\n\n\ndef is_set(obj):\n \"\"\"Helper method to see if the object is a Python set.\n\n >>> is_set(set())\n True\n \"\"\"\n return type(obj) is set\n\n\ndef is_bytes(obj):\n \"\"\"Helper method to see if the object is a bytestring.\n\n >>> is_bytes(b'foo')\n True\n \"\"\"\n return type(obj) is bytes\n\n\ndef is_unicode(obj):\n \"\"\"Helper method to see if the object is a unicode string\"\"\"\n return type(obj) is compat.ustr\n\n\ndef is_tuple(obj):\n \"\"\"Helper method to see if the object is a Python tuple.\n\n >>> is_tuple((1,))\n True\n \"\"\"\n return type(obj) is tuple\n\n\ndef is_dictionary_subclass(obj):\n \"\"\"Returns True if *obj* is a subclass of the dict type. *obj* must be\n a subclass and not the actual builtin dict.\n\n >>> class Temp(dict): pass\n >>> is_dictionary_subclass(Temp())\n True\n \"\"\"\n # TODO: add UserDict\n return (\n hasattr(obj, '__class__')\n and issubclass(obj.__class__, dict)\n and type(obj) is not dict\n )\n\n\ndef is_sequence_subclass(obj):\n \"\"\"Returns True if *obj* is a subclass of list, set or tuple.\n\n *obj* must be a subclass and not the actual builtin, such\n as list, set, tuple, etc..\n\n >>> class Temp(list): pass\n >>> is_sequence_subclass(Temp())\n True\n \"\"\"\n return (\n hasattr(obj, '__class__')\n and (issubclass(obj.__class__, SEQUENCES) or is_list_like(obj))\n and not is_sequence(obj)\n )\n\n\ndef is_noncomplex(obj):\n \"\"\"Returns True if *obj* is a special (weird) class, that is more complex\n than primitive data types, but is not a full object. Including:\n\n * :class:`~time.struct_time`\n \"\"\"\n if type(obj) is time.struct_time:\n return True\n return False\n\n\ndef is_function(obj):\n \"\"\"Returns true if passed a function\n\n >>> is_function(lambda x: 1)\n True\n\n >>> is_function(locals)\n True\n\n >>> def method(): pass\n >>> is_function(method)\n True\n\n >>> is_function(1)\n False\n \"\"\"\n function_types = {\n types.FunctionType,\n types.MethodType,\n types.LambdaType,\n types.BuiltinFunctionType,\n types.BuiltinMethodType,\n }\n return type(obj) in function_types\n\n\ndef is_module_function(obj):\n \"\"\"Return True if `obj` is a module-global function\n\n >>> import os\n >>> is_module_function(os.path.exists)\n True\n\n >>> is_module_function(lambda: None)\n False\n\n \"\"\"\n\n return (\n hasattr(obj, '__class__')\n and isinstance(obj, (types.FunctionType, types.BuiltinFunctionType))\n and hasattr(obj, '__module__')\n and hasattr(obj, '__name__')\n and obj.__name__ != '<lambda>'\n )\n\n\ndef is_module(obj):\n \"\"\"Returns True if passed a module\n\n >>> import os\n >>> is_module(os)\n True\n\n \"\"\"\n return isinstance(obj, types.ModuleType)\n\n\ndef is_picklable(name, value):\n \"\"\"Return True if an object can be pickled\n\n >>> import os\n >>> is_picklable('os', os)\n True\n\n >>> def foo(): pass\n >>> is_picklable('foo', foo)\n True\n\n >>> is_picklable('foo', lambda: None)\n False\n\n \"\"\"\n if name in tags.RESERVED:\n return False\n return is_module_function(value) or not is_function(value)\n\n\ndef is_installed(module):\n \"\"\"Tests to see if ``module`` is available on the sys.path\n\n >>> is_installed('sys')\n True\n >>> is_installed('hopefullythisisnotarealmodule')\n False\n\n \"\"\"\n try:\n __import__(module)\n return True\n except ImportError:\n return False\n\n\ndef is_list_like(obj):\n return hasattr(obj, '__getitem__') and hasattr(obj, 'append')\n\n\ndef is_iterator(obj):\n is_file = PY2 and isinstance(obj, __builtin__.file)\n return (\n isinstance(obj, abc_iterator) and not isinstance(obj, io.IOBase) and not is_file\n )\n\n\ndef is_collections(obj):\n try:\n return type(obj).__module__ == 'collections'\n except Exception:\n return False\n\n\ndef is_reducible_sequence_subclass(obj):\n return hasattr(obj, '__class__') and issubclass(obj.__class__, SEQUENCES)\n\n\ndef is_reducible(obj):\n \"\"\"\n Returns false if of a type which have special casing,\n and should not have their __reduce__ methods used\n \"\"\"\n # defaultdicts may contain functions which we cannot serialise\n if is_collections(obj) and not isinstance(obj, collections.defaultdict):\n return True\n # sets are slightly slower in this case\n if type(obj) in NON_REDUCIBLE_TYPES:\n return False\n elif obj is object:\n return False\n elif is_list_like(obj):\n return False\n elif isinstance(obj, types.ModuleType):\n return False\n elif is_dictionary_subclass(obj):\n return False\n elif is_reducible_sequence_subclass(obj):\n return False\n elif isinstance(getattr(obj, '__slots__', None), iterator_types):\n return False\n elif is_type(obj) and obj.__module__ == 'datetime':\n return False\n return True\n\n\ndef in_dict(obj, key, default=False):\n \"\"\"\n Returns true if key exists in obj.__dict__; false if not in.\n If obj.__dict__ is absent, return default\n \"\"\"\n return (key in obj.__dict__) if getattr(obj, '__dict__', None) else default\n\n\ndef in_slots(obj, key, default=False):\n \"\"\"\n Returns true if key exists in obj.__slots__; false if not in.\n If obj.__slots__ is absent, return default\n \"\"\"\n return (key in obj.__slots__) if getattr(obj, '__slots__', None) else default\n\n\ndef has_reduce(obj):\n \"\"\"\n Tests if __reduce__ or __reduce_ex__ exists in the object dict or\n in the class dicts of every class in the MRO *except object*.\n\n Returns a tuple of booleans (has_reduce, has_reduce_ex)\n \"\"\"\n\n if not is_reducible(obj) or is_type(obj):\n return (False, False)\n\n # in this case, reduce works and is desired\n # notwithstanding depending on default object\n # reduce\n if is_noncomplex(obj):\n return (False, True)\n\n has_reduce = False\n has_reduce_ex = False\n\n REDUCE = '__reduce__'\n REDUCE_EX = '__reduce_ex__'\n\n # For object instance\n has_reduce = in_dict(obj, REDUCE) or in_slots(obj, REDUCE)\n has_reduce_ex = in_dict(obj, REDUCE_EX) or in_slots(obj, REDUCE_EX)\n\n # turn to the MRO\n for base in type(obj).__mro__:\n if is_reducible(base):\n has_reduce = has_reduce or in_dict(base, REDUCE)\n has_reduce_ex = has_reduce_ex or in_dict(base, REDUCE_EX)\n if has_reduce and has_reduce_ex:\n return (has_reduce, has_reduce_ex)\n\n # for things that don't have a proper dict but can be\n # getattred (rare, but includes some builtins)\n cls = type(obj)\n object_reduce = getattr(object, REDUCE)\n object_reduce_ex = getattr(object, REDUCE_EX)\n if not has_reduce:\n has_reduce_cls = getattr(cls, REDUCE, False)\n if has_reduce_cls is not object_reduce:\n has_reduce = has_reduce_cls\n\n if not has_reduce_ex:\n has_reduce_ex_cls = getattr(cls, REDUCE_EX, False)\n if has_reduce_ex_cls is not object_reduce_ex:\n has_reduce_ex = has_reduce_ex_cls\n\n return (has_reduce, has_reduce_ex)\n\n\ndef translate_module_name(module):\n \"\"\"Rename builtin modules to a consistent module name.\n\n Prefer the more modern naming.\n\n This is used so that references to Python's `builtins` module can\n be loaded in both Python 2 and 3. We remap to the \"__builtin__\"\n name and unmap it when importing.\n\n Map the Python2 `exceptions` module to `builtins` because\n `builtins` is a superset and contains everything that is\n available in `exceptions`, which makes the translation simpler.\n\n See untranslate_module_name() for the reverse operation.\n \"\"\"\n lookup = dict(__builtin__='builtins', exceptions='builtins')\n return lookup.get(module, module)\n\n\ndef untranslate_module_name(module):\n \"\"\"Rename module names mention in JSON to names that we can import\n\n This reverses the translation applied by translate_module_name() to\n a module name available to the current version of Python.\n\n \"\"\"\n module = _0_9_6_compat_untranslate(module)\n lookup = dict(builtins='__builtin__') if PY2 else {}\n return lookup.get(module, module)\n\n\ndef _0_9_6_compat_untranslate(module):\n \"\"\"Provide compatibility for pickles created with jsonpickle 0.9.6 and\n earlier, remapping `exceptions` and `__builtin__` to `builtins`.\n \"\"\"\n lookup = dict(__builtin__='builtins', exceptions='builtins')\n return lookup.get(module, module)\n\n\ndef importable_name(cls):\n \"\"\"\n >>> class Example(object):\n ... pass\n\n >>> ex = Example()\n >>> importable_name(ex.__class__) == 'jsonpickle.util.Example'\n True\n >>> importable_name(type(25)) == 'builtins.int'\n True\n >>> importable_name(None.__class__) == 'builtins.NoneType'\n True\n >>> importable_name(False.__class__) == 'builtins.bool'\n True\n >>> importable_name(AttributeError) == 'builtins.AttributeError'\n True\n\n \"\"\"\n # Use the fully-qualified name if available (Python >= 3.3)\n name = getattr(cls, '__qualname__', cls.__name__)\n module = translate_module_name(cls.__module__)\n return '{}.{}'.format(module, name)\n\n\ndef b64encode(data):\n \"\"\"\n Encode binary data to ascii text in base64. Data must be bytes.\n \"\"\"\n return base64.b64encode(data).decode('ascii')\n\n\ndef b64decode(payload):\n \"\"\"\n Decode payload - must be ascii text.\n \"\"\"\n return base64.b64decode(payload)\n\n\ndef b85encode(data):\n \"\"\"\n Encode binary data to ascii text in base85. Data must be bytes.\n \"\"\"\n if PY2:\n raise NotImplementedError(\"Python 2 can't encode data in base85.\")\n return base64.b85encode(data).decode('ascii')\n\n\ndef b85decode(payload):\n \"\"\"\n Decode payload - must be ascii text.\n \"\"\"\n if PY2:\n raise NotImplementedError(\"Python 2 can't decode base85-encoded data.\")\n return base64.b85decode(payload)\n\n\ndef itemgetter(obj, getter=operator.itemgetter(0)):\n return compat.ustr(getter(obj))\n\n\ndef items(obj):\n \"\"\"Iterate over dicts in a deterministic order\n\n Python2 does not guarantee dict ordering, so this function\n papers over the difference in behavior. Python3 does guarantee\n dict order, without use of OrderedDict, so no sorting is needed there.\n\n \"\"\"\n if PY3_ORDERED_DICT:\n for k, v in obj.items():\n yield k, v\n else:\n for k, v in sorted(obj.items(), key=itemgetter):\n yield k, v\n"}}},{"rowIdx":2091,"cells":{"function_name":{"kind":"string","value":"importable_name"},"docstring":{"kind":"string","value":">>> class Example(object):\n... pass\n\n>>> ex = Example()\n>>> importable_name(ex.__class__) == 'jsonpickle.util.Example'\nTrue\n>>> importable_name(type(25)) == 'builtins.int'\nTrue\n>>> importable_name(None.__class__) == 'builtins.NoneType'\nTrue\n>>> importable_name(False.__class__) == 'builtins.bool'\nTrue\n>>> importable_name(AttributeError) == 'builtins.AttributeError'\nTrue"},"masked_code":{"kind":"string","value":"# Copyright (C) 2008 John Paulett (john -at- paulett.org)\n# Copyright (C) 2009-2018 David Aguilar (davvid -at- gmail.com)\n# All rights reserved.\n#\n# This software is licensed as described in the file COPYING, which\n# you should have received as part of this distribution.\n\n\"\"\"Helper functions for pickling and unpickling. Most functions assist in\ndetermining the type of an object.\n\"\"\"\nfrom __future__ import absolute_import, division, unicode_literals\nimport base64\nimport collections\nimport io\nimport operator\nimport sys\nimport time\nimport types\nimport inspect\n\nfrom . import tags\nfrom . import compat\nfrom .compat import (\n abc_iterator,\n class_types,\n iterator_types,\n numeric_types,\n PY2,\n PY3,\n PY3_ORDERED_DICT,\n)\n\nif PY2:\n import __builtin__\n\nSEQUENCES = (list, set, tuple)\nSEQUENCES_SET = {list, set, tuple}\nPRIMITIVES = {compat.ustr, bool, type(None)} | set(numeric_types)\nNON_REDUCIBLE_TYPES = {\n int,\n float,\n list,\n dict,\n set,\n tuple,\n object,\n bytes,\n types.FunctionType,\n types.MethodType,\n types.LambdaType,\n types.BuiltinFunctionType,\n types.BuiltinMethodType,\n} | PRIMITIVES\n\n\ndef is_type(obj):\n \"\"\"Returns True is obj is a reference to a type.\n\n >>> is_type(1)\n False\n\n >>> is_type(object)\n True\n\n >>> class Klass: pass\n >>> is_type(Klass)\n True\n \"\"\"\n # use \"isinstance\" and not \"is\" to allow for metaclasses\n return isinstance(obj, class_types)\n\n\ndef has_method(obj, name):\n # false if attribute doesn't exist\n if not hasattr(obj, name):\n return False\n func = getattr(obj, name)\n\n # builtin descriptors like __getnewargs__\n if isinstance(func, types.BuiltinMethodType):\n return True\n\n # note that FunctionType has a different meaning in py2/py3\n if not isinstance(func, (types.MethodType, types.FunctionType)):\n return False\n\n # need to go through __dict__'s since in py3\n # methods are essentially descriptors\n\n # __class__ for old-style classes\n base_type = obj if is_type(obj) else obj.__class__\n original = None\n # there is no .mro() for old-style classes\n for subtype in inspect.getmro(base_type):\n original = vars(subtype).get(name)\n if original is not None:\n break\n\n # name not found in the mro\n if original is None:\n return False\n\n # static methods are always fine\n if isinstance(original, staticmethod):\n return True\n\n # at this point, the method has to be an instancemthod or a classmethod\n self_attr = '__self__' if PY3 else 'im_self'\n if not hasattr(func, self_attr):\n return False\n bound_to = getattr(func, self_attr)\n\n # class methods\n if isinstance(original, classmethod):\n return issubclass(base_type, bound_to)\n\n # bound methods\n return isinstance(obj, type(bound_to))\n\n\ndef is_object(obj):\n \"\"\"Returns True is obj is a reference to an object instance.\n\n >>> is_object(1)\n True\n\n >>> is_object(object())\n True\n\n >>> is_object(lambda x: 1)\n False\n \"\"\"\n return isinstance(obj, object) and not isinstance(\n obj, (type, types.FunctionType, types.BuiltinFunctionType)\n )\n\n\ndef is_primitive(obj):\n \"\"\"Helper method to see if the object is a basic data type. Unicode strings,\n integers, longs, floats, booleans, and None are considered primitive\n and will return True when passed into *is_primitive()*\n\n >>> is_primitive(3)\n True\n >>> is_primitive([4,4])\n False\n \"\"\"\n return type(obj) in PRIMITIVES\n\n\ndef is_enum(obj):\n \"\"\"Is the object an enum?\"\"\"\n return 'enum' in sys.modules and isinstance(obj, sys.modules['enum'].Enum)\n\n\ndef is_dictionary(obj):\n \"\"\"Helper method for testing if the object is a dictionary.\n\n >>> is_dictionary({'key':'value'})\n True\n\n \"\"\"\n return type(obj) is dict\n\n\ndef is_sequence(obj):\n \"\"\"Helper method to see if the object is a sequence (list, set, or tuple).\n\n >>> is_sequence([4])\n True\n\n \"\"\"\n return type(obj) in SEQUENCES_SET\n\n\ndef is_list(obj):\n \"\"\"Helper method to see if the object is a Python list.\n\n >>> is_list([4])\n True\n \"\"\"\n return type(obj) is list\n\n\ndef is_set(obj):\n \"\"\"Helper method to see if the object is a Python set.\n\n >>> is_set(set())\n True\n \"\"\"\n return type(obj) is set\n\n\ndef is_bytes(obj):\n \"\"\"Helper method to see if the object is a bytestring.\n\n >>> is_bytes(b'foo')\n True\n \"\"\"\n return type(obj) is bytes\n\n\ndef is_unicode(obj):\n \"\"\"Helper method to see if the object is a unicode string\"\"\"\n return type(obj) is compat.ustr\n\n\ndef is_tuple(obj):\n \"\"\"Helper method to see if the object is a Python tuple.\n\n >>> is_tuple((1,))\n True\n \"\"\"\n return type(obj) is tuple\n\n\ndef is_dictionary_subclass(obj):\n \"\"\"Returns True if *obj* is a subclass of the dict type. *obj* must be\n a subclass and not the actual builtin dict.\n\n >>> class Temp(dict): pass\n >>> is_dictionary_subclass(Temp())\n True\n \"\"\"\n # TODO: add UserDict\n return (\n hasattr(obj, '__class__')\n and issubclass(obj.__class__, dict)\n and type(obj) is not dict\n )\n\n\ndef is_sequence_subclass(obj):\n \"\"\"Returns True if *obj* is a subclass of list, set or tuple.\n\n *obj* must be a subclass and not the actual builtin, such\n as list, set, tuple, etc..\n\n >>> class Temp(list): pass\n >>> is_sequence_subclass(Temp())\n True\n \"\"\"\n return (\n hasattr(obj, '__class__')\n and (issubclass(obj.__class__, SEQUENCES) or is_list_like(obj))\n and not is_sequence(obj)\n )\n\n\ndef is_noncomplex(obj):\n \"\"\"Returns True if *obj* is a special (weird) class, that is more complex\n than primitive data types, but is not a full object. Including:\n\n * :class:`~time.struct_time`\n \"\"\"\n if type(obj) is time.struct_time:\n return True\n return False\n\n\ndef is_function(obj):\n \"\"\"Returns true if passed a function\n\n >>> is_function(lambda x: 1)\n True\n\n >>> is_function(locals)\n True\n\n >>> def method(): pass\n >>> is_function(method)\n True\n\n >>> is_function(1)\n False\n \"\"\"\n function_types = {\n types.FunctionType,\n types.MethodType,\n types.LambdaType,\n types.BuiltinFunctionType,\n types.BuiltinMethodType,\n }\n return type(obj) in function_types\n\n\ndef is_module_function(obj):\n \"\"\"Return True if `obj` is a module-global function\n\n >>> import os\n >>> is_module_function(os.path.exists)\n True\n\n >>> is_module_function(lambda: None)\n False\n\n \"\"\"\n\n return (\n hasattr(obj, '__class__')\n and isinstance(obj, (types.FunctionType, types.BuiltinFunctionType))\n and hasattr(obj, '__module__')\n and hasattr(obj, '__name__')\n and obj.__name__ != '<lambda>'\n )\n\n\ndef is_module(obj):\n \"\"\"Returns True if passed a module\n\n >>> import os\n >>> is_module(os)\n True\n\n \"\"\"\n return isinstance(obj, types.ModuleType)\n\n\ndef is_picklable(name, value):\n \"\"\"Return True if an object can be pickled\n\n >>> import os\n >>> is_picklable('os', os)\n True\n\n >>> def foo(): pass\n >>> is_picklable('foo', foo)\n True\n\n >>> is_picklable('foo', lambda: None)\n False\n\n \"\"\"\n if name in tags.RESERVED:\n return False\n return is_module_function(value) or not is_function(value)\n\n\ndef is_installed(module):\n \"\"\"Tests to see if ``module`` is available on the sys.path\n\n >>> is_installed('sys')\n True\n >>> is_installed('hopefullythisisnotarealmodule')\n False\n\n \"\"\"\n try:\n __import__(module)\n return True\n except ImportError:\n return False\n\n\ndef is_list_like(obj):\n return hasattr(obj, '__getitem__') and hasattr(obj, 'append')\n\n\ndef is_iterator(obj):\n is_file = PY2 and isinstance(obj, __builtin__.file)\n return (\n isinstance(obj, abc_iterator) and not isinstance(obj, io.IOBase) and not is_file\n )\n\n\ndef is_collections(obj):\n try:\n return type(obj).__module__ == 'collections'\n except Exception:\n return False\n\n\ndef is_reducible_sequence_subclass(obj):\n return hasattr(obj, '__class__') and issubclass(obj.__class__, SEQUENCES)\n\n\ndef is_reducible(obj):\n \"\"\"\n Returns false if of a type which have special casing,\n and should not have their __reduce__ methods used\n \"\"\"\n # defaultdicts may contain functions which we cannot serialise\n if is_collections(obj) and not isinstance(obj, collections.defaultdict):\n return True\n # sets are slightly slower in this case\n if type(obj) in NON_REDUCIBLE_TYPES:\n return False\n elif obj is object:\n return False\n elif is_list_like(obj):\n return False\n elif isinstance(obj, types.ModuleType):\n return False\n elif is_dictionary_subclass(obj):\n return False\n elif is_reducible_sequence_subclass(obj):\n return False\n elif isinstance(getattr(obj, '__slots__', None), iterator_types):\n return False\n elif is_type(obj) and obj.__module__ == 'datetime':\n return False\n return True\n\n\ndef in_dict(obj, key, default=False):\n \"\"\"\n Returns true if key exists in obj.__dict__; false if not in.\n If obj.__dict__ is absent, return default\n \"\"\"\n return (key in obj.__dict__) if getattr(obj, '__dict__', None) else default\n\n\ndef in_slots(obj, key, default=False):\n \"\"\"\n Returns true if key exists in obj.__slots__; false if not in.\n If obj.__slots__ is absent, return default\n \"\"\"\n return (key in obj.__slots__) if getattr(obj, '__slots__', None) else default\n\n\ndef has_reduce(obj):\n \"\"\"\n Tests if __reduce__ or __reduce_ex__ exists in the object dict or\n in the class dicts of every class in the MRO *except object*.\n\n Returns a tuple of booleans (has_reduce, has_reduce_ex)\n \"\"\"\n\n if not is_reducible(obj) or is_type(obj):\n return (False, False)\n\n # in this case, reduce works and is desired\n # notwithstanding depending on default object\n # reduce\n if is_noncomplex(obj):\n return (False, True)\n\n has_reduce = False\n has_reduce_ex = False\n\n REDUCE = '__reduce__'\n REDUCE_EX = '__reduce_ex__'\n\n # For object instance\n has_reduce = in_dict(obj, REDUCE) or in_slots(obj, REDUCE)\n has_reduce_ex = in_dict(obj, REDUCE_EX) or in_slots(obj, REDUCE_EX)\n\n # turn to the MRO\n for base in type(obj).__mro__:\n if is_reducible(base):\n has_reduce = has_reduce or in_dict(base, REDUCE)\n has_reduce_ex = has_reduce_ex or in_dict(base, REDUCE_EX)\n if has_reduce and has_reduce_ex:\n return (has_reduce, has_reduce_ex)\n\n # for things that don't have a proper dict but can be\n # getattred (rare, but includes some builtins)\n cls = type(obj)\n object_reduce = getattr(object, REDUCE)\n object_reduce_ex = getattr(object, REDUCE_EX)\n if not has_reduce:\n has_reduce_cls = getattr(cls, REDUCE, False)\n if has_reduce_cls is not object_reduce:\n has_reduce = has_reduce_cls\n\n if not has_reduce_ex:\n has_reduce_ex_cls = getattr(cls, REDUCE_EX, False)\n if has_reduce_ex_cls is not object_reduce_ex:\n has_reduce_ex = has_reduce_ex_cls\n\n return (has_reduce, has_reduce_ex)\n\n\ndef translate_module_name(module):\n \"\"\"Rename builtin modules to a consistent module name.\n\n Prefer the more modern naming.\n\n This is used so that references to Python's `builtins` module can\n be loaded in both Python 2 and 3. We remap to the \"__builtin__\"\n name and unmap it when importing.\n\n Map the Python2 `exceptions` module to `builtins` because\n `builtins` is a superset and contains everything that is\n available in `exceptions`, which makes the translation simpler.\n\n See untranslate_module_name() for the reverse operation.\n \"\"\"\n lookup = dict(__builtin__='builtins', exceptions='builtins')\n return lookup.get(module, module)\n\n\ndef untranslate_module_name(module):\n \"\"\"Rename module names mention in JSON to names that we can import\n\n This reverses the translation applied by translate_module_name() to\n a module name available to the current version of Python.\n\n \"\"\"\n module = _0_9_6_compat_untranslate(module)\n lookup = dict(builtins='__builtin__') if PY2 else {}\n return lookup.get(module, module)\n\n\ndef _0_9_6_compat_untranslate(module):\n \"\"\"Provide compatibility for pickles created with jsonpickle 0.9.6 and\n earlier, remapping `exceptions` and `__builtin__` to `builtins`.\n \"\"\"\n lookup = dict(__builtin__='builtins', exceptions='builtins')\n return lookup.get(module, module)\n\n\n# MASKED: importable_name function (lines 513-534)\n\n\ndef b64encode(data):\n \"\"\"\n Encode binary data to ascii text in base64. Data must be bytes.\n \"\"\"\n return base64.b64encode(data).decode('ascii')\n\n\ndef b64decode(payload):\n \"\"\"\n Decode payload - must be ascii text.\n \"\"\"\n return base64.b64decode(payload)\n\n\ndef b85encode(data):\n \"\"\"\n Encode binary data to ascii text in base85. Data must be bytes.\n \"\"\"\n if PY2:\n raise NotImplementedError(\"Python 2 can't encode data in base85.\")\n return base64.b85encode(data).decode('ascii')\n\n\ndef b85decode(payload):\n \"\"\"\n Decode payload - must be ascii text.\n \"\"\"\n if PY2:\n raise NotImplementedError(\"Python 2 can't decode base85-encoded data.\")\n return base64.b85decode(payload)\n\n\ndef itemgetter(obj, getter=operator.itemgetter(0)):\n return compat.ustr(getter(obj))\n\n\ndef items(obj):\n \"\"\"Iterate over dicts in a deterministic order\n\n Python2 does not guarantee dict ordering, so this function\n papers over the difference in behavior. Python3 does guarantee\n dict order, without use of OrderedDict, so no sorting is needed there.\n\n \"\"\"\n if PY3_ORDERED_DICT:\n for k, v in obj.items():\n yield k, v\n else:\n for k, v in sorted(obj.items(), key=itemgetter):\n yield k, v"},"implementation":{"kind":"string","value":"def importable_name(cls):\n \"\"\"\n >>> class Example(object):\n ... pass\n\n >>> ex = Example()\n >>> importable_name(ex.__class__) == 'jsonpickle.util.Example'\n True\n >>> importable_name(type(25)) == 'builtins.int'\n True\n >>> importable_name(None.__class__) == 'builtins.NoneType'\n True\n >>> importable_name(False.__class__) == 'builtins.bool'\n True\n >>> importable_name(AttributeError) == 'builtins.AttributeError'\n True\n\n \"\"\"\n # Use the fully-qualified name if available (Python >= 3.3)\n name = getattr(cls, '__qualname__', cls.__name__)\n module = translate_module_name(cls.__module__)\n return '{}.{}'.format(module, name)"},"start_line":{"kind":"number","value":513,"string":"513"},"end_line":{"kind":"number","value":534,"string":"534"},"file_content":{"kind":"string","value":"# Copyright (C) 2008 John Paulett (john -at- paulett.org)\n# Copyright (C) 2009-2018 David Aguilar (davvid -at- gmail.com)\n# All rights reserved.\n#\n# This software is licensed as described in the file COPYING, which\n# you should have received as part of this distribution.\n\n\"\"\"Helper functions for pickling and unpickling. Most functions assist in\ndetermining the type of an object.\n\"\"\"\nfrom __future__ import absolute_import, division, unicode_literals\nimport base64\nimport collections\nimport io\nimport operator\nimport sys\nimport time\nimport types\nimport inspect\n\nfrom . import tags\nfrom . import compat\nfrom .compat import (\n abc_iterator,\n class_types,\n iterator_types,\n numeric_types,\n PY2,\n PY3,\n PY3_ORDERED_DICT,\n)\n\nif PY2:\n import __builtin__\n\nSEQUENCES = (list, set, tuple)\nSEQUENCES_SET = {list, set, tuple}\nPRIMITIVES = {compat.ustr, bool, type(None)} | set(numeric_types)\nNON_REDUCIBLE_TYPES = {\n int,\n float,\n list,\n dict,\n set,\n tuple,\n object,\n bytes,\n types.FunctionType,\n types.MethodType,\n types.LambdaType,\n types.BuiltinFunctionType,\n types.BuiltinMethodType,\n} | PRIMITIVES\n\n\ndef is_type(obj):\n \"\"\"Returns True is obj is a reference to a type.\n\n >>> is_type(1)\n False\n\n >>> is_type(object)\n True\n\n >>> class Klass: pass\n >>> is_type(Klass)\n True\n \"\"\"\n # use \"isinstance\" and not \"is\" to allow for metaclasses\n return isinstance(obj, class_types)\n\n\ndef has_method(obj, name):\n # false if attribute doesn't exist\n if not hasattr(obj, name):\n return False\n func = getattr(obj, name)\n\n # builtin descriptors like __getnewargs__\n if isinstance(func, types.BuiltinMethodType):\n return True\n\n # note that FunctionType has a different meaning in py2/py3\n if not isinstance(func, (types.MethodType, types.FunctionType)):\n return False\n\n # need to go through __dict__'s since in py3\n # methods are essentially descriptors\n\n # __class__ for old-style classes\n base_type = obj if is_type(obj) else obj.__class__\n original = None\n # there is no .mro() for old-style classes\n for subtype in inspect.getmro(base_type):\n original = vars(subtype).get(name)\n if original is not None:\n break\n\n # name not found in the mro\n if original is None:\n return False\n\n # static methods are always fine\n if isinstance(original, staticmethod):\n return True\n\n # at this point, the method has to be an instancemthod or a classmethod\n self_attr = '__self__' if PY3 else 'im_self'\n if not hasattr(func, self_attr):\n return False\n bound_to = getattr(func, self_attr)\n\n # class methods\n if isinstance(original, classmethod):\n return issubclass(base_type, bound_to)\n\n # bound methods\n return isinstance(obj, type(bound_to))\n\n\ndef is_object(obj):\n \"\"\"Returns True is obj is a reference to an object instance.\n\n >>> is_object(1)\n True\n\n >>> is_object(object())\n True\n\n >>> is_object(lambda x: 1)\n False\n \"\"\"\n return isinstance(obj, object) and not isinstance(\n obj, (type, types.FunctionType, types.BuiltinFunctionType)\n )\n\n\ndef is_primitive(obj):\n \"\"\"Helper method to see if the object is a basic data type. Unicode strings,\n integers, longs, floats, booleans, and None are considered primitive\n and will return True when passed into *is_primitive()*\n\n >>> is_primitive(3)\n True\n >>> is_primitive([4,4])\n False\n \"\"\"\n return type(obj) in PRIMITIVES\n\n\ndef is_enum(obj):\n \"\"\"Is the object an enum?\"\"\"\n return 'enum' in sys.modules and isinstance(obj, sys.modules['enum'].Enum)\n\n\ndef is_dictionary(obj):\n \"\"\"Helper method for testing if the object is a dictionary.\n\n >>> is_dictionary({'key':'value'})\n True\n\n \"\"\"\n return type(obj) is dict\n\n\ndef is_sequence(obj):\n \"\"\"Helper method to see if the object is a sequence (list, set, or tuple).\n\n >>> is_sequence([4])\n True\n\n \"\"\"\n return type(obj) in SEQUENCES_SET\n\n\ndef is_list(obj):\n \"\"\"Helper method to see if the object is a Python list.\n\n >>> is_list([4])\n True\n \"\"\"\n return type(obj) is list\n\n\ndef is_set(obj):\n \"\"\"Helper method to see if the object is a Python set.\n\n >>> is_set(set())\n True\n \"\"\"\n return type(obj) is set\n\n\ndef is_bytes(obj):\n \"\"\"Helper method to see if the object is a bytestring.\n\n >>> is_bytes(b'foo')\n True\n \"\"\"\n return type(obj) is bytes\n\n\ndef is_unicode(obj):\n \"\"\"Helper method to see if the object is a unicode string\"\"\"\n return type(obj) is compat.ustr\n\n\ndef is_tuple(obj):\n \"\"\"Helper method to see if the object is a Python tuple.\n\n >>> is_tuple((1,))\n True\n \"\"\"\n return type(obj) is tuple\n\n\ndef is_dictionary_subclass(obj):\n \"\"\"Returns True if *obj* is a subclass of the dict type. *obj* must be\n a subclass and not the actual builtin dict.\n\n >>> class Temp(dict): pass\n >>> is_dictionary_subclass(Temp())\n True\n \"\"\"\n # TODO: add UserDict\n return (\n hasattr(obj, '__class__')\n and issubclass(obj.__class__, dict)\n and type(obj) is not dict\n )\n\n\ndef is_sequence_subclass(obj):\n \"\"\"Returns True if *obj* is a subclass of list, set or tuple.\n\n *obj* must be a subclass and not the actual builtin, such\n as list, set, tuple, etc..\n\n >>> class Temp(list): pass\n >>> is_sequence_subclass(Temp())\n True\n \"\"\"\n return (\n hasattr(obj, '__class__')\n and (issubclass(obj.__class__, SEQUENCES) or is_list_like(obj))\n and not is_sequence(obj)\n )\n\n\ndef is_noncomplex(obj):\n \"\"\"Returns True if *obj* is a special (weird) class, that is more complex\n than primitive data types, but is not a full object. Including:\n\n * :class:`~time.struct_time`\n \"\"\"\n if type(obj) is time.struct_time:\n return True\n return False\n\n\ndef is_function(obj):\n \"\"\"Returns true if passed a function\n\n >>> is_function(lambda x: 1)\n True\n\n >>> is_function(locals)\n True\n\n >>> def method(): pass\n >>> is_function(method)\n True\n\n >>> is_function(1)\n False\n \"\"\"\n function_types = {\n types.FunctionType,\n types.MethodType,\n types.LambdaType,\n types.BuiltinFunctionType,\n types.BuiltinMethodType,\n }\n return type(obj) in function_types\n\n\ndef is_module_function(obj):\n \"\"\"Return True if `obj` is a module-global function\n\n >>> import os\n >>> is_module_function(os.path.exists)\n True\n\n >>> is_module_function(lambda: None)\n False\n\n \"\"\"\n\n return (\n hasattr(obj, '__class__')\n and isinstance(obj, (types.FunctionType, types.BuiltinFunctionType))\n and hasattr(obj, '__module__')\n and hasattr(obj, '__name__')\n and obj.__name__ != '<lambda>'\n )\n\n\ndef is_module(obj):\n \"\"\"Returns True if passed a module\n\n >>> import os\n >>> is_module(os)\n True\n\n \"\"\"\n return isinstance(obj, types.ModuleType)\n\n\ndef is_picklable(name, value):\n \"\"\"Return True if an object can be pickled\n\n >>> import os\n >>> is_picklable('os', os)\n True\n\n >>> def foo(): pass\n >>> is_picklable('foo', foo)\n True\n\n >>> is_picklable('foo', lambda: None)\n False\n\n \"\"\"\n if name in tags.RESERVED:\n return False\n return is_module_function(value) or not is_function(value)\n\n\ndef is_installed(module):\n \"\"\"Tests to see if ``module`` is available on the sys.path\n\n >>> is_installed('sys')\n True\n >>> is_installed('hopefullythisisnotarealmodule')\n False\n\n \"\"\"\n try:\n __import__(module)\n return True\n except ImportError:\n return False\n\n\ndef is_list_like(obj):\n return hasattr(obj, '__getitem__') and hasattr(obj, 'append')\n\n\ndef is_iterator(obj):\n is_file = PY2 and isinstance(obj, __builtin__.file)\n return (\n isinstance(obj, abc_iterator) and not isinstance(obj, io.IOBase) and not is_file\n )\n\n\ndef is_collections(obj):\n try:\n return type(obj).__module__ == 'collections'\n except Exception:\n return False\n\n\ndef is_reducible_sequence_subclass(obj):\n return hasattr(obj, '__class__') and issubclass(obj.__class__, SEQUENCES)\n\n\ndef is_reducible(obj):\n \"\"\"\n Returns false if of a type which have special casing,\n and should not have their __reduce__ methods used\n \"\"\"\n # defaultdicts may contain functions which we cannot serialise\n if is_collections(obj) and not isinstance(obj, collections.defaultdict):\n return True\n # sets are slightly slower in this case\n if type(obj) in NON_REDUCIBLE_TYPES:\n return False\n elif obj is object:\n return False\n elif is_list_like(obj):\n return False\n elif isinstance(obj, types.ModuleType):\n return False\n elif is_dictionary_subclass(obj):\n return False\n elif is_reducible_sequence_subclass(obj):\n return False\n elif isinstance(getattr(obj, '__slots__', None), iterator_types):\n return False\n elif is_type(obj) and obj.__module__ == 'datetime':\n return False\n return True\n\n\ndef in_dict(obj, key, default=False):\n \"\"\"\n Returns true if key exists in obj.__dict__; false if not in.\n If obj.__dict__ is absent, return default\n \"\"\"\n return (key in obj.__dict__) if getattr(obj, '__dict__', None) else default\n\n\ndef in_slots(obj, key, default=False):\n \"\"\"\n Returns true if key exists in obj.__slots__; false if not in.\n If obj.__slots__ is absent, return default\n \"\"\"\n return (key in obj.__slots__) if getattr(obj, '__slots__', None) else default\n\n\ndef has_reduce(obj):\n \"\"\"\n Tests if __reduce__ or __reduce_ex__ exists in the object dict or\n in the class dicts of every class in the MRO *except object*.\n\n Returns a tuple of booleans (has_reduce, has_reduce_ex)\n \"\"\"\n\n if not is_reducible(obj) or is_type(obj):\n return (False, False)\n\n # in this case, reduce works and is desired\n # notwithstanding depending on default object\n # reduce\n if is_noncomplex(obj):\n return (False, True)\n\n has_reduce = False\n has_reduce_ex = False\n\n REDUCE = '__reduce__'\n REDUCE_EX = '__reduce_ex__'\n\n # For object instance\n has_reduce = in_dict(obj, REDUCE) or in_slots(obj, REDUCE)\n has_reduce_ex = in_dict(obj, REDUCE_EX) or in_slots(obj, REDUCE_EX)\n\n # turn to the MRO\n for base in type(obj).__mro__:\n if is_reducible(base):\n has_reduce = has_reduce or in_dict(base, REDUCE)\n has_reduce_ex = has_reduce_ex or in_dict(base, REDUCE_EX)\n if has_reduce and has_reduce_ex:\n return (has_reduce, has_reduce_ex)\n\n # for things that don't have a proper dict but can be\n # getattred (rare, but includes some builtins)\n cls = type(obj)\n object_reduce = getattr(object, REDUCE)\n object_reduce_ex = getattr(object, REDUCE_EX)\n if not has_reduce:\n has_reduce_cls = getattr(cls, REDUCE, False)\n if has_reduce_cls is not object_reduce:\n has_reduce = has_reduce_cls\n\n if not has_reduce_ex:\n has_reduce_ex_cls = getattr(cls, REDUCE_EX, False)\n if has_reduce_ex_cls is not object_reduce_ex:\n has_reduce_ex = has_reduce_ex_cls\n\n return (has_reduce, has_reduce_ex)\n\n\ndef translate_module_name(module):\n \"\"\"Rename builtin modules to a consistent module name.\n\n Prefer the more modern naming.\n\n This is used so that references to Python's `builtins` module can\n be loaded in both Python 2 and 3. We remap to the \"__builtin__\"\n name and unmap it when importing.\n\n Map the Python2 `exceptions` module to `builtins` because\n `builtins` is a superset and contains everything that is\n available in `exceptions`, which makes the translation simpler.\n\n See untranslate_module_name() for the reverse operation.\n \"\"\"\n lookup = dict(__builtin__='builtins', exceptions='builtins')\n return lookup.get(module, module)\n\n\ndef untranslate_module_name(module):\n \"\"\"Rename module names mention in JSON to names that we can import\n\n This reverses the translation applied by translate_module_name() to\n a module name available to the current version of Python.\n\n \"\"\"\n module = _0_9_6_compat_untranslate(module)\n lookup = dict(builtins='__builtin__') if PY2 else {}\n return lookup.get(module, module)\n\n\ndef _0_9_6_compat_untranslate(module):\n \"\"\"Provide compatibility for pickles created with jsonpickle 0.9.6 and\n earlier, remapping `exceptions` and `__builtin__` to `builtins`.\n \"\"\"\n lookup = dict(__builtin__='builtins', exceptions='builtins')\n return lookup.get(module, module)\n\n\ndef importable_name(cls):\n \"\"\"\n >>> class Example(object):\n ... pass\n\n >>> ex = Example()\n >>> importable_name(ex.__class__) == 'jsonpickle.util.Example'\n True\n >>> importable_name(type(25)) == 'builtins.int'\n True\n >>> importable_name(None.__class__) == 'builtins.NoneType'\n True\n >>> importable_name(False.__class__) == 'builtins.bool'\n True\n >>> importable_name(AttributeError) == 'builtins.AttributeError'\n True\n\n \"\"\"\n # Use the fully-qualified name if available (Python >= 3.3)\n name = getattr(cls, '__qualname__', cls.__name__)\n module = translate_module_name(cls.__module__)\n return '{}.{}'.format(module, name)\n\n\ndef b64encode(data):\n \"\"\"\n Encode binary data to ascii text in base64. Data must be bytes.\n \"\"\"\n return base64.b64encode(data).decode('ascii')\n\n\ndef b64decode(payload):\n \"\"\"\n Decode payload - must be ascii text.\n \"\"\"\n return base64.b64decode(payload)\n\n\ndef b85encode(data):\n \"\"\"\n Encode binary data to ascii text in base85. Data must be bytes.\n \"\"\"\n if PY2:\n raise NotImplementedError(\"Python 2 can't encode data in base85.\")\n return base64.b85encode(data).decode('ascii')\n\n\ndef b85decode(payload):\n \"\"\"\n Decode payload - must be ascii text.\n \"\"\"\n if PY2:\n raise NotImplementedError(\"Python 2 can't decode base85-encoded data.\")\n return base64.b85decode(payload)\n\n\ndef itemgetter(obj, getter=operator.itemgetter(0)):\n return compat.ustr(getter(obj))\n\n\ndef items(obj):\n \"\"\"Iterate over dicts in a deterministic order\n\n Python2 does not guarantee dict ordering, so this function\n papers over the difference in behavior. Python3 does guarantee\n dict order, without use of OrderedDict, so no sorting is needed there.\n\n \"\"\"\n if PY3_ORDERED_DICT:\n for k, v in obj.items():\n yield k, v\n else:\n for k, v in sorted(obj.items(), key=itemgetter):\n yield k, v\n"}}},{"rowIdx":2092,"cells":{"function_name":{"kind":"string","value":"__init__"},"docstring":{"kind":"string","value":"Init crea\n\n:param str node: Node to connect to *(optional)*\n:param str rpcuser: RPC user *(optional)*\n:param str rpcpassword: RPC password *(optional)*\n:param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n:param bool unsigned: Do **not** sign a transaction! *(optional)*\n:param bool debug: Enable Debugging *(optional)*\n:param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n:param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n:param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n:param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n:param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n:param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n:param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n:param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n:param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n:param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n:param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True"},"masked_code":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n# MASKED: __init__ function (lines 133-214)\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)"},"implementation":{"kind":"string","value":" def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True"},"start_line":{"kind":"number","value":133,"string":"133"},"end_line":{"kind":"number","value":214,"string":"214"},"file_content":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)\n"}}},{"rowIdx":2093,"cells":{"function_name":{"kind":"string","value":"get_reward_funds"},"docstring":{"kind":"string","value":"Get details for a reward fund.\n\n:param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used."},"masked_code":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n# MASKED: get_reward_funds function (lines 333-359)\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)"},"implementation":{"kind":"string","value":" def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret"},"start_line":{"kind":"number","value":333,"string":"333"},"end_line":{"kind":"number","value":359,"string":"359"},"file_content":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)\n"}}},{"rowIdx":2094,"cells":{"function_name":{"kind":"string","value":"get_crea_per_mvest"},"docstring":{"kind":"string","value":"Returns the MVEST to CREA ratio\n\n:param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)"},"masked_code":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n# MASKED: get_crea_per_mvest function (lines 532-556)\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)"},"implementation":{"kind":"string","value":" def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )"},"start_line":{"kind":"number","value":532,"string":"532"},"end_line":{"kind":"number","value":556,"string":"556"},"file_content":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)\n"}}},{"rowIdx":2095,"cells":{"function_name":{"kind":"string","value":"sbd_to_vote_pct"},"docstring":{"kind":"string","value":"Obtain the voting percentage for a desired CBD value\nfor a given Crea Power or vesting shares and voting power\nGive either Crea Power or vests, not both.\nWhen the output is greater than 10000 or smaller than -10000,\nthe CBD value is too high.\n\nReturns the required voting percentage (100% = 10000)\n\n:param sbd: desired CBD value\n:type sbd: str, int, amount.Amount\n:param number crea_power: Crea Power\n:param number vests: vesting shares\n:param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool."},"masked_code":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n# MASKED: sbd_to_vote_pct function (lines 728-755)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)"},"implementation":{"kind":"string","value":" def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)"},"start_line":{"kind":"number","value":728,"string":"728"},"end_line":{"kind":"number","value":755,"string":"755"},"file_content":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)\n"}}},{"rowIdx":2096,"cells":{"function_name":{"kind":"string","value":"claim_account"},"docstring":{"kind":"string","value":"Claim account for claimed account creation.\n\nWhen fee is 0 CREA a subsidized account is claimed and can be created\nlater with create_claimed_account.\nThe number of subsidized account is limited.\n\n:param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n:param str fee: when set to 0 CREA (default), claim account is paid by RC"},"masked_code":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n# MASKED: claim_account function (lines 1049-1074)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)"},"implementation":{"kind":"string","value":" def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)"},"start_line":{"kind":"number","value":1049,"string":"1,049"},"end_line":{"kind":"number","value":1074,"string":"1,074"},"file_content":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)\n"}}},{"rowIdx":2097,"cells":{"function_name":{"kind":"string","value":"custom_json"},"docstring":{"kind":"string","value":"Create a custom json operation\n\n:param str id: identifier for the custom json (max length 32 bytes)\n:param json json_data: the json data to put into the custom_json\n operation\n:param list required_auths: (optional) required auths\n:param list required_posting_auths: (optional) posting auths\n\n.. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n.. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])"},"masked_code":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n# MASKED: custom_json function (lines 1567-1607)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)"},"implementation":{"kind":"string","value":" def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)"},"start_line":{"kind":"number","value":1567,"string":"1,567"},"end_line":{"kind":"number","value":1607,"string":"1,607"},"file_content":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)\n"}}},{"rowIdx":2098,"cells":{"function_name":{"kind":"string","value":"comment_options"},"docstring":{"kind":"string","value":"Set the comment options\n\n:param dict options: The options to define.\n:param str identifier: Post identifier\n:param list beneficiaries: (optional) list of beneficiaries\n:param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\nFor the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }"},"masked_code":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n# MASKED: comment_options function (lines 1814-1844)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)"},"implementation":{"kind":"string","value":" def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)"},"start_line":{"kind":"number","value":1814,"string":"1,814"},"end_line":{"kind":"number","value":1844,"string":"1,844"},"file_content":{"kind":"string","value":"# This Python file uses the following encoding: utf-8\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom builtins import str\nfrom builtins import object\nimport json\nimport logging\nimport re\nimport os\nimport math\nimport ast\nimport time\nfrom creagraphenebase.py23 import bytes_types, integer_types, string_types, text_type\nfrom datetime import datetime, timedelta, date\nfrom creaapi.creanoderpc import CreaNodeRPC\nfrom creaapi.exceptions import NoAccessApi, NoApiWithName\nfrom creagraphenebase.account import PrivateKey, PublicKey\nfrom creabase import transactions, operations\nfrom creagraphenebase.chains import known_chains\nfrom .account import Account\nfrom .amount import Amount\nfrom .price import Price\nfrom .storage import configStorage as config\nfrom .version import version as crea_version\nfrom .exceptions import (\n AccountExistsException,\n AccountDoesNotExistsException\n)\nfrom .wallet import Wallet\nfrom .creaconnect import CreaConnect\nfrom .transactionbuilder import TransactionBuilder\nfrom .utils import formatTime, resolve_authorperm, derive_permlink, remove_from_dict, addTzInfo, formatToTimeStamp\nfrom crea.constants import CREA_VOTE_REGENERATION_SECONDS, CREA_100_PERCENT, CREA_1_PERCENT, CREA_RC_REGEN_TIME\n\nlog = logging.getLogger(__name__)\n\n\nclass Crea(object):\n \"\"\" Connect to the Crea network.\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type keys: array, dict, string\n :param wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :type wif: array, dict, string\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcasted transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations. It is not possible to send out more than one\n vote operation and more than one comment operation in a single broadcast *(optional)*\n :param bool appbase: Use the new appbase rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for\n broadcast posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n :param dict custom_chains: custom chain which should be added to the known chains\n\n Three wallet operation modes are possible:\n\n * **Wallet Database**: Here, the crealibs load the keys from the\n locally stored wallet SQLite database (see ``storage.py``).\n To use this mode, simply call ``Crea()`` without the\n ``keys`` parameter\n * **Providing Keys**: Here, you can provide the keys for\n your accounts manually. All you need to do is add the wif\n keys for the accounts you want to use as a simple array\n using the ``keys`` parameter to ``Crea()``.\n * **Force keys**: This more is for advanced users and\n requires that you know what you are doing. Here, the\n ``keys`` parameter is a dictionary that overwrite the\n ``active``, ``owner``, ``posting`` or ``memo`` keys for\n any account. This mode is only used for *foreign*\n signatures!\n\n If no node is provided, it will connect to default nodes of\n http://geo.crea.pl. Default settings can be changed with:\n\n .. code-block:: python\n\n crea = Crea(<host>)\n\n where ``<host>`` starts with ``https://``, ``ws://`` or ``wss://``.\n\n The purpose of this class it to simplify interaction with\n Crea.\n\n The idea is to have a class that allows to do this:\n\n .. code-block:: python\n\n >>> from crea import Crea\n >>> crea = Crea()\n >>> print(crea.get_blockchain_version()) # doctest: +SKIP\n\n This class also deals with edits, votes and reading content.\n\n Example for adding a custom chain:\n\n .. code-block:: python\n\n from crea import Crea\n stm = Crea(node=[\"https://mytstnet.com\"], custom_chains={\"MYTESTNET\":\n {'chain_assets': [{'asset': 'CBD', 'id': 0, 'precision': 3, 'symbol': 'CBD'},\n {'asset': 'CREA', 'id': 1, 'precision': 3, 'symbol': 'CREA'},\n {'asset': 'VESTS', 'id': 2, 'precision': 6, 'symbol': 'VESTS'}],\n 'chain_id': '79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01674',\n 'min_version': '0.0.0',\n 'prefix': 'MTN'}\n }\n )\n\n \"\"\"\n\n def __init__(self,\n node=\"\",\n rpcuser=None,\n rpcpassword=None,\n debug=False,\n data_refresh_time_seconds=900,\n **kwargs):\n \"\"\"Init crea\n\n :param str node: Node to connect to *(optional)*\n :param str rpcuser: RPC user *(optional)*\n :param str rpcpassword: RPC password *(optional)*\n :param bool nobroadcast: Do **not** broadcast a transaction!\n *(optional)*\n :param bool unsigned: Do **not** sign a transaction! *(optional)*\n :param bool debug: Enable Debugging *(optional)*\n :param array,dict,string keys: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param array,dict,string wif: Predefine the wif keys to shortcut the\n wallet database *(optional)*\n :param bool offline: Boolean to prevent connecting to network (defaults\n to ``False``) *(optional)*\n :param int expiration: Delay in seconds until transactions are supposed\n to expire *(optional)* (default is 30)\n :param str blocking: Wait for broadcast transactions to be included\n in a block and return full transaction (can be \"head\" or\n \"irreversible\")\n :param bool bundle: Do not broadcast transactions right away, but allow\n to bundle operations *(optional)*\n :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version\n 0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.\n :param int num_retries: Set the maximum number of reconnects to the nodes before\n NumRetriesReached is raised. Disabled for -1. (default is -1)\n :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)\n :param int timeout: Timeout setting for https nodes (default is 60)\n :param bool use_sc2: When True, a creaconnect object is created. Can be used for broadcast\n posting op or creating hot_links (default is False)\n :param CreaConnect creaconnect: A CreaConnect object can be set manually, set use_sc2 to True\n\n \"\"\"\n\n self.rpc = None\n self.debug = debug\n\n self.offline = bool(kwargs.get(\"offline\", False))\n self.nobroadcast = bool(kwargs.get(\"nobroadcast\", False))\n self.unsigned = bool(kwargs.get(\"unsigned\", False))\n self.expiration = int(kwargs.get(\"expiration\", 30))\n self.bundle = bool(kwargs.get(\"bundle\", False))\n self.creaconnect = kwargs.get(\"creaconnect\", None)\n self.use_sc2 = bool(kwargs.get(\"use_sc2\", False))\n self.blocking = kwargs.get(\"blocking\", False)\n self.custom_chains = kwargs.get(\"custom_chains\", {})\n\n # Store config for access through other Classes\n self.config = config\n\n if not self.offline:\n self.connect(node=node,\n rpcuser=rpcuser,\n rpcpassword=rpcpassword,\n **kwargs)\n\n self.data = {'last_refresh': None, 'last_node': None, 'dynamic_global_properties': None, 'feed_history': None,\n 'get_feed_history': None, 'hardfork_properties': None,\n 'network': None, 'witness_schedule': None,\n 'config': None, 'reward_funds': None}\n self.data_refresh_time_seconds = data_refresh_time_seconds\n # self.refresh_data()\n\n # txbuffers/propbuffer are initialized and cleared\n self.clear()\n\n self.wallet = Wallet(crea_instance=self, **kwargs)\n\n # set creaconnect\n if self.creaconnect is not None and not isinstance(self.creaconnect, CreaConnect):\n raise ValueError(\"creaconnect musst be CreaConnect object\")\n if self.creaconnect is None and self.use_sc2:\n self.creaconnect = CreaConnect(crea_instance=self, **kwargs)\n elif self.creaconnect is not None and not self.use_sc2:\n self.use_sc2 = True\n\n # -------------------------------------------------------------------------\n # Basic Calls\n # -------------------------------------------------------------------------\n def connect(self,\n node=\"\",\n rpcuser=\"\",\n rpcpassword=\"\",\n **kwargs):\n \"\"\" Connect to Crea network (internal use only)\n \"\"\"\n if not node:\n node = self.get_default_nodes()\n if not bool(node):\n raise ValueError(\"A Crea node needs to be provided!\")\n\n if not rpcuser and \"rpcuser\" in config:\n rpcuser = config[\"rpcuser\"]\n\n if not rpcpassword and \"rpcpassword\" in config:\n rpcpassword = config[\"rpcpassword\"]\n\n self.rpc = CreaNodeRPC(node, rpcuser, rpcpassword, **kwargs)\n\n def is_connected(self):\n \"\"\"Returns if rpc is connected\"\"\"\n return self.rpc is not None\n\n def __repr__(self):\n if self.offline:\n return \"<%s offline=True>\" % (\n self.__class__.__name__)\n elif self.rpc is not None and len(self.rpc.url) > 0:\n return \"<%s node=%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.rpc.url), str(self.nobroadcast))\n else:\n return \"<%s, nobroadcast=%s>\" % (\n self.__class__.__name__, str(self.nobroadcast))\n\n def refresh_data(self, force_refresh=False, data_refresh_time_seconds=None):\n \"\"\" Read and stores crea blockchain parameters\n If the last data refresh is older than data_refresh_time_seconds, data will be refreshed\n\n :param bool force_refresh: if True, a refresh of the data is enforced\n :param float data_refresh_time_seconds: set a new minimal refresh time in seconds\n\n \"\"\"\n if self.offline:\n return\n if data_refresh_time_seconds is not None:\n self.data_refresh_time_seconds = data_refresh_time_seconds\n if self.data['last_refresh'] is not None and not force_refresh and self.data[\"last_node\"] == self.rpc.url:\n if (datetime.utcnow() - self.data['last_refresh']).total_seconds() < self.data_refresh_time_seconds:\n return\n self.data['last_refresh'] = datetime.utcnow()\n self.data[\"last_node\"] = self.rpc.url\n self.data[\"dynamic_global_properties\"] = self.get_dynamic_global_properties(False)\n try:\n self.data['feed_history'] = self.get_feed_history(False)\n self.data['get_feed_history'] = self.get_feed_history(False)\n except:\n self.data['feed_history'] = None\n self.data['get_feed_history'] = None\n try:\n self.data['hardfork_properties'] = self.get_hardfork_properties(False)\n except:\n self.data['hardfork_properties'] = None\n self.data['network'] = self.get_network(False)\n self.data['witness_schedule'] = self.get_witness_schedule(False)\n self.data['config'] = self.get_config(False)\n self.data['reward_funds'] = self.get_reward_funds(False)\n\n def get_dynamic_global_properties(self, use_stored_data=True):\n \"\"\" This call returns the *dynamic global properties*\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['dynamic_global_properties']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_dynamic_global_properties(api=\"database\")\n\n def get_reserve_ratio(self):\n \"\"\" This call returns the *reserve ratio*\n \"\"\"\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n return self.rpc.get_reserve_ratio(api=\"witness\")\n else:\n props = self.get_dynamic_global_properties()\n # conf = self.get_config()\n reserve_ratio = {'id': 0, 'average_block_size': props['average_block_size'],\n 'current_reserve_ratio': props['current_reserve_ratio'],\n 'max_virtual_bandwidth': props['max_virtual_bandwidth']}\n return reserve_ratio\n\n def get_feed_history(self, use_stored_data=True):\n \"\"\" Returns the feed_history\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['feed_history']\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_feed_history(api=\"database\")\n\n def get_reward_funds(self, use_stored_data=True):\n \"\"\" Get details for a reward fund.\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['reward_funds']\n\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n funds = self.rpc.get_reward_funds(api=\"database\")\n if funds is not None:\n funds = funds['funds']\n else:\n return None\n if len(funds) > 0:\n funds = funds[0]\n ret = funds\n else:\n ret = self.rpc.get_reward_fund(\"post\", api=\"database\")\n return ret\n\n def get_current_median_history(self, use_stored_data=True):\n \"\"\" Returns the current median price\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n if self.data['get_feed_history']:\n return self.data['get_feed_history']['current_median_history']\n else:\n return None\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_feed_history(api=\"database\")['current_median_history']\n else:\n ret = self.rpc.get_current_median_history_price(api=\"database\")\n return ret\n\n def get_hardfork_properties(self, use_stored_data=True):\n \"\"\" Returns Hardfork and live_time of the hardfork\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['hardfork_properties']\n if self.rpc is None:\n return None\n ret = None\n self.rpc.set_next_node_on_empty_reply(True)\n if self.rpc.get_use_appbase():\n ret = self.rpc.get_hardfork_properties(api=\"database\")\n else:\n ret = self.rpc.get_next_scheduled_hardfork(api=\"database\")\n\n return ret\n\n def get_network(self, use_stored_data=True):\n \"\"\" Identify the network\n\n :param bool use_stored_data: if True, stored data will be returned. If stored data are\n empty or old, refresh_data() is used.\n\n :returns: Network parameters\n :rtype: dictionary\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['network']\n\n if self.rpc is None:\n return None\n try:\n return self.rpc.get_network()\n except:\n return known_chains[\"CREA\"]\n\n def get_median_price(self, use_stored_data=True):\n \"\"\" Returns the current median history price as Price\n \"\"\"\n median_price = self.get_current_median_history(use_stored_data=use_stored_data)\n if median_price is None:\n return None\n a = Price(\n None,\n base=Amount(median_price['base'], crea_instance=self),\n quote=Amount(median_price['quote'], crea_instance=self),\n crea_instance=self\n )\n return a.as_base(self.sbd_symbol)\n\n def get_block_interval(self, use_stored_data=True):\n \"\"\"Returns the block interval in seconds\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n block_interval = 3\n if props is None:\n return block_interval\n for key in props:\n if key[-14:] == \"BLOCK_INTERVAL\":\n block_interval = props[key]\n\n return block_interval\n\n def get_blockchain_version(self, use_stored_data=True):\n \"\"\"Returns the blockchain version\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n blockchain_version = '0.0.0'\n if props is None:\n return blockchain_version\n for key in props:\n if key[-18:] == \"BLOCKCHAIN_VERSION\":\n blockchain_version = props[key]\n return blockchain_version\n\n def get_dust_threshold(self, use_stored_data=True):\n \"\"\"Returns the vote dust threshold\"\"\"\n props = self.get_config(use_stored_data=use_stored_data)\n dust_threshold = 0\n if props is None:\n return dust_threshold\n for key in props:\n if key[-20:] == \"VOTE_DUST_THRESHOLD\":\n dust_threshold = props[key]\n return dust_threshold\n\n def get_resource_params(self):\n \"\"\"Returns the resource parameter\"\"\"\n return self.rpc.get_resource_params(api=\"rc\")[\"resource_params\"]\n\n def get_resource_pool(self):\n \"\"\"Returns the resource pool\"\"\"\n return self.rpc.get_resource_pool(api=\"rc\")[\"resource_pool\"]\n\n def get_rc_cost(self, resource_count):\n \"\"\"Returns the RC costs based on the resource_count\"\"\"\n pools = self.get_resource_pool()\n params = self.get_resource_params()\n config = self.get_config()\n dyn_param = self.get_dynamic_global_properties()\n rc_regen = int(Amount(dyn_param[\"total_vesting_shares\"], crea_instance=self)) / (CREA_RC_REGEN_TIME / config[\"CREA_BLOCK_INTERVAL\"])\n total_cost = 0\n if rc_regen == 0:\n return total_cost\n for resource_type in resource_count:\n curve_params = params[resource_type][\"price_curve_params\"]\n current_pool = int(pools[resource_type][\"pool\"])\n count = resource_count[resource_type]\n count *= params[resource_type][\"resource_dynamics_params\"][\"resource_unit\"]\n cost = self._compute_rc_cost(curve_params, current_pool, count, rc_regen)\n total_cost += cost\n return total_cost\n\n def _compute_rc_cost(self, curve_params, current_pool, resource_count, rc_regen):\n \"\"\"Helper function for computing the RC costs\"\"\"\n num = int(rc_regen)\n num *= int(curve_params['coeff_a'])\n num = int(num) >> int(curve_params['shift'])\n num += 1\n num *= int(resource_count)\n denom = int(curve_params['coeff_b'])\n if int(current_pool) > 0:\n denom += int(current_pool)\n num_denom = num / denom\n return int(num_denom) + 1\n\n def rshares_to_sbd(self, rshares, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Calculates the current CBD value of a vote\n \"\"\"\n payout = float(rshares) * self.get_sbd_per_rshares(use_stored_data=use_stored_data,\n not_broadcasted_vote_rshares=rshares if not_broadcasted_vote else 0)\n return payout\n\n def get_sbd_per_rshares(self, not_broadcasted_vote_rshares=0, use_stored_data=True):\n \"\"\" Returns the current rshares to CBD ratio\n \"\"\"\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self).amount\n recent_claims = float(reward_fund[\"recent_claims\"]) + not_broadcasted_vote_rshares\n\n fund_per_share = reward_balance / (recent_claims)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n if median_price is None:\n return 0\n CBD_price = (median_price * Amount(1, self.crea_symbol, crea_instance=self)).amount\n return fund_per_share * CBD_price\n\n def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):\n \"\"\" Returns the MVEST to CREA ratio\n\n :param int time_stamp: (optional) if set, return an estimated\n CREA per MVEST ratio for the given time stamp. If unset the\n current ratio is returned (default). (can also be a datetime object)\n \"\"\"\n if time_stamp is not None:\n if isinstance(time_stamp, (datetime, date)):\n time_stamp = formatToTimeStamp(time_stamp)\n a = 2.1325476281078992e-05\n b = -31099.685481490847\n a2 = 2.9019227739473682e-07\n b2 = 48.41432402074669\n\n if (time_stamp < (b2 - b) / (a - a2)):\n return a * time_stamp + b\n else:\n return a2 * time_stamp + b2\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n return (\n Amount(global_properties['total_vesting_fund_crea'], crea_instance=self).amount /\n (Amount(global_properties['total_vesting_shares'], crea_instance=self).amount / 1e6)\n )\n\n def vests_to_sp(self, vests, timestamp=None, use_stored_data=True):\n \"\"\" Converts vests to SP\n\n :param amount.Amount vests/float vests: Vests to convert\n :param int timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n\n \"\"\"\n if isinstance(vests, Amount):\n vests = vests.amount\n return vests / 1e6 * self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_vests(self, sp, timestamp=None, use_stored_data=True):\n \"\"\" Converts SP to vests\n\n :param float sp: Crea power to convert\n :param datetime timestamp: (Optional) Can be used to calculate\n the conversion rate from the past\n \"\"\"\n return sp * 1e6 / self.get_crea_per_mvest(timestamp, use_stored_data=use_stored_data)\n\n def sp_to_sbd(self, sp, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vesting_shares = int(self.sp_to_vests(sp, use_stored_data=use_stored_data))\n return self.vests_to_sbd(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def vests_to_sbd(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the resulting CBD vote value from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n\n Only impactful for very big votes. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n \"\"\"\n vote_rshares = self.vests_to_rshares(vests, voting_power=voting_power, vote_pct=vote_pct)\n return self.rshares_to_sbd(vote_rshares, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n\n def _max_vote_denom(self, use_stored_data=True):\n # get props\n global_properties = self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n vote_power_reserve_rate = global_properties['vote_power_reserve_rate']\n max_vote_denom = vote_power_reserve_rate * CREA_VOTE_REGENERATION_SECONDS\n return max_vote_denom\n\n def _calc_resulting_vote(self, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n # determine voting power used\n used_power = int((voting_power * abs(vote_pct)) / CREA_100_PERCENT * (60 * 60 * 24))\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n used_power = int((used_power + max_vote_denom - 1) / max_vote_denom)\n return used_power\n\n def sp_to_rshares(self, crea_power, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the r-shares from Crea power\n\n :param number crea_power: Crea Power\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n # calculate our account voting shares (from vests)\n vesting_shares = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data))\n return self.vests_to_rshares(vesting_shares, voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n\n def vests_to_rshares(self, vests, voting_power=CREA_100_PERCENT, vote_pct=CREA_100_PERCENT, subtract_dust_threshold=True, use_stored_data=True):\n \"\"\" Obtain the r-shares from vests\n\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n :param int vote_pct: voting percentage (100% = 10000)\n\n \"\"\"\n used_power = self._calc_resulting_vote(voting_power=voting_power, vote_pct=vote_pct, use_stored_data=use_stored_data)\n # calculate vote rshares\n rshares = int(math.copysign(vests * 1e6 * used_power / CREA_100_PERCENT, vote_pct))\n if subtract_dust_threshold:\n if abs(rshares) <= self.get_dust_threshold(use_stored_data=use_stored_data):\n return 0\n rshares -= math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), vote_pct)\n return rshares\n\n def sbd_to_rshares(self, sbd, not_broadcasted_vote=False, use_stored_data=True):\n \"\"\" Obtain the r-shares from CBD\n\n :param sbd: CBD\n :type sbd: str, int, amount.Amount\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError('Should input CBD, not any other asset!')\n\n # If the vote was already broadcasted we can assume the blockchain values to be true\n if not not_broadcasted_vote:\n return int(sbd.amount / self.get_sbd_per_rshares(use_stored_data=use_stored_data))\n\n # If the vote wasn't broadcasted (yet), we have to calculate the rshares while considering\n # the change our vote is causing to the recent_claims. This is more important for really\n # big votes which have a significant impact on the recent_claims.\n reward_fund = self.get_reward_funds(use_stored_data=use_stored_data)\n median_price = self.get_median_price(use_stored_data=use_stored_data)\n recent_claims = int(reward_fund[\"recent_claims\"])\n reward_balance = Amount(reward_fund[\"reward_balance\"], crea_instance=self)\n reward_pool_sbd = median_price * reward_balance\n if sbd > reward_pool_sbd:\n raise ValueError('Provided more CBD than available in the reward pool.')\n\n # This is the formula we can use to determine the \"true\" rshares.\n # We get this formula by some math magic using the previous used formulas\n # FundsPerShare = (balance / (claims + newShares)) * Price\n # newShares = amount / FundsPerShare\n # We can now resolve both formulas for FundsPerShare and set the formulas to be equal\n # (balance / (claims + newShares)) * price = amount / newShares\n # Now we resolve for newShares resulting in:\n # newShares = claims * amount / (balance * price - amount)\n rshares = recent_claims * sbd.amount / ((reward_balance.amount * float(median_price)) - sbd.amount)\n return int(rshares)\n\n def rshares_to_vote_pct(self, rshares, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired rshares value\n for a given Crea Power or vesting shares and voting_power\n Give either crea_power or vests, not both.\n When the output is greater than 10000 or less than -10000,\n the given absolute rshares are too high\n\n Returns the required voting percentage (100% = 10000)\n\n :param number rshares: desired rshares value\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param int voting_power: voting power (100% = 10000)\n\n \"\"\"\n if crea_power is None and vests is None:\n raise ValueError(\"Either crea_power or vests has to be set!\")\n if crea_power is not None and vests is not None:\n raise ValueError(\"Either crea_power or vests has to be set. Not both!\")\n if crea_power is not None:\n vests = int(self.sp_to_vests(crea_power, use_stored_data=use_stored_data) * 1e6)\n\n if self.hardfork >= 20:\n rshares += math.copysign(self.get_dust_threshold(use_stored_data=use_stored_data), rshares)\n\n max_vote_denom = self._max_vote_denom(use_stored_data=use_stored_data)\n\n used_power = int(math.ceil(abs(rshares) * CREA_100_PERCENT / vests))\n used_power = used_power * max_vote_denom\n\n vote_pct = used_power * CREA_100_PERCENT / (60 * 60 * 24) / voting_power\n return int(math.copysign(vote_pct, rshares))\n\n def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):\n \"\"\" Obtain the voting percentage for a desired CBD value\n for a given Crea Power or vesting shares and voting power\n Give either Crea Power or vests, not both.\n When the output is greater than 10000 or smaller than -10000,\n the CBD value is too high.\n\n Returns the required voting percentage (100% = 10000)\n\n :param sbd: desired CBD value\n :type sbd: str, int, amount.Amount\n :param number crea_power: Crea Power\n :param number vests: vesting shares\n :param bool not_broadcasted_vote: not_broadcasted or already broadcasted vote (True = not_broadcasted vote).\n Only impactful for very high amounts of CBD. Slight modification to the value calculation, as the not_broadcasted\n vote rshares decreases the reward pool.\n\n \"\"\"\n if isinstance(sbd, Amount):\n sbd = Amount(sbd, crea_instance=self)\n elif isinstance(sbd, string_types):\n sbd = Amount(sbd, crea_instance=self)\n else:\n sbd = Amount(sbd, self.sbd_symbol, crea_instance=self)\n if sbd['symbol'] != self.sbd_symbol:\n raise AssertionError()\n rshares = self.sbd_to_rshares(sbd, not_broadcasted_vote=not_broadcasted_vote, use_stored_data=use_stored_data)\n return self.rshares_to_vote_pct(rshares, crea_power=crea_power, vests=vests, voting_power=voting_power, use_stored_data=use_stored_data)\n\n def get_chain_properties(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n Properties:::\n\n {\n 'account_creation_fee': '30.000 CREA',\n 'maximum_block_size': 65536,\n 'sbd_interest_rate': 250\n }\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']['median_props']\n else:\n return self.get_witness_schedule(use_stored_data)['median_props']\n\n def get_witness_schedule(self, use_stored_data=True):\n \"\"\" Return witness elected chain properties\n\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n return self.data['witness_schedule']\n\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n return self.rpc.get_witness_schedule(api=\"database\")\n\n def get_config(self, use_stored_data=True):\n \"\"\" Returns internal chain configuration.\n\n :param bool use_stored_data: If True, the cached value is returned\n \"\"\"\n if use_stored_data:\n self.refresh_data()\n config = self.data['config']\n else:\n if self.rpc is None:\n return None\n self.rpc.set_next_node_on_empty_reply(True)\n config = self.rpc.get_config(api=\"database\")\n return config\n\n @property\n def chain_params(self):\n if self.offline or self.rpc is None:\n return known_chains[\"CREA\"]\n else:\n return self.get_network()\n\n @property\n def hardfork(self):\n if self.offline or self.rpc is None:\n versions = known_chains['CREA']['min_version']\n else:\n hf_prop = self.get_hardfork_properties()\n if \"current_hardfork_version\" in hf_prop:\n versions = hf_prop[\"current_hardfork_version\"]\n else:\n versions = self.get_blockchain_version()\n return int(versions.split('.')[1])\n\n @property\n def prefix(self):\n return self.chain_params[\"prefix\"]\n\n def set_default_account(self, account):\n \"\"\" Set the default account to be used\n \"\"\"\n Account(account, crea_instance=self)\n config[\"default_account\"] = account\n\n def set_password_storage(self, password_storage):\n \"\"\" Set the password storage mode.\n\n When set to \"no\", the password has to be provided each time.\n When set to \"environment\" the password is taken from the\n UNLOCK variable\n\n When set to \"keyring\" the password is taken from the\n python keyring module. A wallet password can be stored with\n python -m keyring set crea wallet password\n\n :param str password_storage: can be \"no\",\n \"keyring\" or \"environment\"\n\n \"\"\"\n config[\"password_storage\"] = password_storage\n\n def set_default_nodes(self, nodes):\n \"\"\" Set the default nodes to be used\n \"\"\"\n if bool(nodes):\n if isinstance(nodes, list):\n nodes = str(nodes)\n config[\"node\"] = nodes\n else:\n config.delete(\"node\")\n\n def get_default_nodes(self):\n \"\"\"Returns the default nodes\"\"\"\n if \"node\" in config:\n nodes = config[\"node\"]\n elif \"nodes\" in config:\n nodes = config[\"nodes\"]\n elif \"default_nodes\" in config and bool(config[\"default_nodes\"]):\n nodes = config[\"default_nodes\"]\n else:\n nodes = []\n if isinstance(nodes, str) and nodes[0] == '[' and nodes[-1] == ']':\n nodes = ast.literal_eval(nodes)\n return nodes\n\n def move_current_node_to_front(self):\n \"\"\"Returns the default node list, until the first entry\n is equal to the current working node url\n \"\"\"\n node = self.get_default_nodes()\n if len(node) < 2:\n return\n offline = self.offline\n while not offline and node[0] != self.rpc.url and len(node) > 1:\n node = node[1:] + [node[0]]\n self.set_default_nodes(node)\n\n def set_default_vote_weight(self, vote_weight):\n \"\"\" Set the default vote weight to be used\n \"\"\"\n config[\"default_vote_weight\"] = vote_weight\n\n def finalizeOp(self, ops, account, permission, **kwargs):\n \"\"\" This method obtains the required private keys if present in\n the wallet, finalizes the transaction, signs it and\n broadacasts it\n\n :param ops: The operation (or list of operations) to\n broadcast\n :type ops: list, GrapheneObject\n :param Account account: The account that authorizes the\n operation\n :param string permission: The required permission for\n signing (active, owner, posting)\n :param TransactionBuilder append_to: This allows to provide an instance of\n TransactionBuilder (see :func:`Crea.new_tx()`) to specify\n where to put a specific operation.\n\n .. note:: ``append_to`` is exposed to every method used in the\n Crea class\n\n .. note:: If ``ops`` is a list of operation, they all need to be\n signable by the same key! Thus, you cannot combine ops\n that require active permission with ops that require\n posting permission. Neither can you use different\n accounts for different operations!\n\n .. note:: This uses :func:`Crea.txbuffer` as instance of\n :class:`crea.transactionbuilder.TransactionBuilder`.\n You may want to use your own txbuffer\n \"\"\"\n if self.offline:\n return {}\n if \"append_to\" in kwargs and kwargs[\"append_to\"]:\n\n # Append to the append_to and return\n append_to = kwargs[\"append_to\"]\n parent = append_to.get_parent()\n if not isinstance(append_to, (TransactionBuilder)):\n raise AssertionError()\n append_to.appendOps(ops)\n # Add the signer to the buffer so we sign the tx properly\n parent.appendSigner(account, permission)\n # This returns as we used append_to, it does NOT broadcast, or sign\n return append_to.get_parent()\n # Go forward to see what the other options do ...\n else:\n # Append to the default buffer\n self.txbuffer.appendOps(ops)\n\n # Add signing information, signer, sign and optionally broadcast\n if self.unsigned:\n # In case we don't want to sign anything\n self.txbuffer.addSigningInformation(account, permission)\n return self.txbuffer\n elif self.bundle:\n # In case we want to add more ops to the tx (bundle)\n self.txbuffer.appendSigner(account, permission)\n return self.txbuffer.json()\n else:\n # default behavior: sign + broadcast\n self.txbuffer.appendSigner(account, permission)\n self.txbuffer.sign()\n return self.txbuffer.broadcast()\n\n def sign(self, tx=None, wifs=[], reconstruct_tx=True):\n \"\"\" Sign a provided transaction with the provided key(s)\n\n :param dict tx: The transaction to be signed and returned\n :param string wifs: One or many wif keys to use for signing\n a transaction. If not present, the keys will be loaded\n from the wallet as defined in \"missing_signatures\" key\n of the transactions.\n :param bool reconstruct_tx: when set to False and tx\n is already contructed, it will not reconstructed\n and already added signatures remain\n\n \"\"\"\n if tx:\n txbuffer = TransactionBuilder(tx, crea_instance=self)\n else:\n txbuffer = self.txbuffer\n txbuffer.appendWif(wifs)\n txbuffer.appendMissingSignatures()\n txbuffer.sign(reconstruct_tx=reconstruct_tx)\n return txbuffer.json()\n\n def broadcast(self, tx=None):\n \"\"\" Broadcast a transaction to the Crea network\n\n :param tx tx: Signed transaction to broadcast\n\n \"\"\"\n if tx:\n # If tx is provided, we broadcast the tx\n return TransactionBuilder(tx, crea_instance=self).broadcast()\n else:\n return self.txbuffer.broadcast()\n\n def info(self, use_stored_data=True):\n \"\"\" Returns the global properties\n \"\"\"\n return self.get_dynamic_global_properties(use_stored_data=use_stored_data)\n\n # -------------------------------------------------------------------------\n # Wallet stuff\n # -------------------------------------------------------------------------\n def newWallet(self, pwd):\n \"\"\" Create a new wallet. This method is basically only calls\n :func:`crea.wallet.Wallet.create`.\n\n :param str pwd: Password to use for the new wallet\n\n :raises WalletExists: if there is already a\n wallet created\n\n \"\"\"\n return self.wallet.create(pwd)\n\n def unlock(self, *args, **kwargs):\n \"\"\" Unlock the internal wallet\n \"\"\"\n return self.wallet.unlock(*args, **kwargs)\n\n # -------------------------------------------------------------------------\n # Transaction Buffers\n # -------------------------------------------------------------------------\n @property\n def txbuffer(self):\n \"\"\" Returns the currently active tx buffer\n \"\"\"\n return self.tx()\n\n def tx(self):\n \"\"\" Returns the default transaction buffer\n \"\"\"\n return self._txbuffers[0]\n\n def new_tx(self, *args, **kwargs):\n \"\"\" Let's obtain a new txbuffer\n\n :returns: id of the new txbuffer\n :rtype: int\n \"\"\"\n builder = TransactionBuilder(\n *args,\n crea_instance=self,\n **kwargs\n )\n self._txbuffers.append(builder)\n return builder\n\n def clear(self):\n self._txbuffers = []\n # Base/Default proposal/tx buffers\n self.new_tx()\n # self.new_proposal()\n\n # -------------------------------------------------------------------------\n # Account related calls\n # -------------------------------------------------------------------------\n def claim_account(self, creator, fee=None, **kwargs):\n \"\"\" Claim account for claimed account creation.\n\n When fee is 0 CREA a subsidized account is claimed and can be created\n later with create_claimed_account.\n The number of subsidized account is limited.\n\n :param str creator: which account should pay the registration fee (RC or CREA)\n (defaults to ``default_account``)\n :param str fee: when set to 0 CREA (default), claim account is paid by RC\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n creator = Account(creator, crea_instance=self)\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_claimed_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n combine_with_claim_account=False,\n fee=None,\n **kwargs\n ):\n \"\"\" Create new claimed account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n :param bool combine_with_claim_account: When set to True, a\n claim_account operation is additionally broadcasted\n :param str fee: When combine_with_claim_account is set to True,\n this parameter is used for the claim_account operation\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n fee = fee if fee is not None else \"0 %s\" % (self.crea_symbol)\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n if combine_with_claim_account:\n op = {\n \"fee\": Amount(fee, crea_instance=self),\n \"creator\": creator[\"name\"],\n \"prefix\": self.prefix,\n }\n op = operations.Claim_account(**op)\n ops = [op]\n op = {\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': active_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Create_claimed_account(**op)\n if combine_with_claim_account:\n ops.append(op)\n return self.finalizeOp(ops, creator, \"active\", **kwargs)\n else:\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def create_account(\n self,\n account_name,\n creator=None,\n owner_key=None,\n active_key=None,\n memo_key=None,\n posting_key=None,\n password=None,\n additional_owner_keys=[],\n additional_active_keys=[],\n additional_posting_keys=[],\n additional_owner_accounts=[],\n additional_active_accounts=[],\n additional_posting_accounts=[],\n storekeys=True,\n store_owner_key=False,\n json_meta=None,\n **kwargs\n ):\n \"\"\" Create new account on Crea\n\n The brainkey/password can be used to recover all generated keys\n (see :class:`creagraphenebase.account` for more details.\n\n By default, this call will use ``default_account`` to\n register a new name ``account_name`` with all keys being\n derived from a new brain key that will be returned. The\n corresponding keys will automatically be installed in the\n wallet.\n\n .. warning:: Don't call this method unless you know what\n you are doing! Be sure to understand what this\n method does and where to find the private keys\n for your account.\n\n .. note:: Please note that this imports private keys\n (if password is present) into the wallet by\n default when nobroadcast is set to False.\n However, it **does not import the owner\n key** for security reasons by default.\n If you set store_owner_key to True, the\n owner key is stored.\n Do NOT expect to be able to recover it from\n the wallet if you lose your password!\n\n .. note:: Account creations cost a fee that is defined by\n the network. If you create an account, you will\n need to pay for that fee!\n\n :param str account_name: (**required**) new account name\n :param str json_meta: Optional meta data for the account\n :param str owner_key: Main owner key\n :param str active_key: Main active key\n :param str posting_key: Main posting key\n :param str memo_key: Main memo_key\n :param str password: Alternatively to providing keys, one\n can provide a password from which the\n keys will be derived\n :param array additional_owner_keys: Additional owner public keys\n :param array additional_active_keys: Additional active public keys\n :param array additional_posting_keys: Additional posting public keys\n :param array additional_owner_accounts: Additional owner account\n names\n :param array additional_active_accounts: Additional acctive account\n names\n :param bool storekeys: Store new keys in the wallet (default:\n ``True``)\n\n :param str creator: which account should pay the registration fee\n (defaults to ``default_account``)\n :raises AccountExistsException: if the account already exists on\n the blockchain\n\n \"\"\"\n if not creator and config[\"default_account\"]:\n creator = config[\"default_account\"]\n if not creator:\n raise ValueError(\n \"Not creator account given. Define it with \" +\n \"creator=x, or set the default_account using creapy\")\n if password and (owner_key or active_key or memo_key):\n raise ValueError(\n \"You cannot use 'password' AND provide keys!\"\n )\n\n try:\n Account(account_name, crea_instance=self)\n raise AccountExistsException\n except AccountDoesNotExistsException:\n pass\n\n creator = Account(creator, crea_instance=self)\n\n \" Generate new keys from password\"\n from creagraphenebase.account import PasswordKey\n if password:\n active_key = PasswordKey(account_name, password, role=\"active\", prefix=self.prefix)\n owner_key = PasswordKey(account_name, password, role=\"owner\", prefix=self.prefix)\n posting_key = PasswordKey(account_name, password, role=\"posting\", prefix=self.prefix)\n memo_key = PasswordKey(account_name, password, role=\"memo\", prefix=self.prefix)\n active_pubkey = active_key.get_public_key()\n owner_pubkey = owner_key.get_public_key()\n posting_pubkey = posting_key.get_public_key()\n memo_pubkey = memo_key.get_public_key()\n active_privkey = active_key.get_private_key()\n posting_privkey = posting_key.get_private_key()\n owner_privkey = owner_key.get_private_key()\n memo_privkey = memo_key.get_private_key()\n # store private keys\n try:\n if storekeys and not self.nobroadcast:\n if store_owner_key:\n self.wallet.addPrivateKey(str(owner_privkey))\n self.wallet.addPrivateKey(str(active_privkey))\n self.wallet.addPrivateKey(str(memo_privkey))\n self.wallet.addPrivateKey(str(posting_privkey))\n except ValueError as e:\n log.info(str(e))\n\n elif (owner_key and active_key and memo_key and posting_key):\n active_pubkey = PublicKey(\n active_key, prefix=self.prefix)\n owner_pubkey = PublicKey(\n owner_key, prefix=self.prefix)\n posting_pubkey = PublicKey(\n posting_key, prefix=self.prefix)\n memo_pubkey = PublicKey(\n memo_key, prefix=self.prefix)\n else:\n raise ValueError(\n \"Call incomplete! Provide either a password or public keys!\"\n )\n owner = format(owner_pubkey, self.prefix)\n active = format(active_pubkey, self.prefix)\n posting = format(posting_pubkey, self.prefix)\n memo = format(memo_pubkey, self.prefix)\n\n owner_key_authority = [[owner, 1]]\n active_key_authority = [[active, 1]]\n posting_key_authority = [[posting, 1]]\n owner_accounts_authority = []\n active_accounts_authority = []\n posting_accounts_authority = []\n\n # additional authorities\n for k in additional_owner_keys:\n owner_key_authority.append([k, 1])\n for k in additional_active_keys:\n active_key_authority.append([k, 1])\n for k in additional_posting_keys:\n posting_key_authority.append([k, 1])\n\n for k in additional_owner_accounts:\n addaccount = Account(k, crea_instance=self)\n owner_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_active_accounts:\n addaccount = Account(k, crea_instance=self)\n active_accounts_authority.append([addaccount[\"name\"], 1])\n for k in additional_posting_accounts:\n addaccount = Account(k, crea_instance=self)\n posting_accounts_authority.append([addaccount[\"name\"], 1])\n\n props = self.get_chain_properties()\n if self.hardfork >= 20:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self)\n else:\n required_fee_crea = Amount(props[\"account_creation_fee\"], crea_instance=self) * 30\n op = {\n \"fee\": required_fee_crea,\n \"creator\": creator[\"name\"],\n \"new_account_name\": account_name,\n 'owner': {'account_auths': owner_accounts_authority,\n 'key_auths': owner_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'active': {'account_auths': active_accounts_authority,\n 'key_auths': active_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'posting': {'account_auths': posting_accounts_authority,\n 'key_auths': posting_key_authority,\n \"address_auths\": [],\n 'weight_threshold': 1},\n 'memo_key': memo,\n \"json_metadata\": json_meta or {},\n \"prefix\": self.prefix,\n }\n op = operations.Account_create(**op)\n return self.finalizeOp(op, creator, \"active\", **kwargs)\n\n def witness_set_properties(self, wif, owner, props, use_condenser_api=True):\n \"\"\" Set witness properties\n\n :param str wif: Private signing key\n :param dict props: Properties\n :param str owner: witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": x,\n \"account_subsidy_budget\": x,\n \"account_subsidy_decay\": x,\n \"maximum_block_size\": x,\n \"url\": x,\n \"sbd_exchange_rate\": x,\n \"sbd_interest_rate\": x,\n \"new_signing_key\": x\n }\n\n \"\"\"\n\n owner = Account(owner, crea_instance=self)\n\n try:\n PrivateKey(wif, prefix=self.prefix)\n except Exception as e:\n raise e\n props_list = [[\"key\", repr(PrivateKey(wif, prefix=self.prefix).pubkey)]]\n for k in props:\n props_list.append([k, props[k]])\n\n op = operations.Witness_set_properties({\"owner\": owner[\"name\"], \"props\": props_list, \"prefix\": self.prefix})\n tb = TransactionBuilder(use_condenser_api=use_condenser_api, crea_instance=self)\n tb.appendOps([op])\n tb.appendWif(wif)\n tb.sign()\n return tb.broadcast()\n\n def witness_update(self, signing_key, url, props, account=None, **kwargs):\n \"\"\" Creates/updates a witness\n\n :param str signing_key: Public signing key\n :param str url: URL\n :param dict props: Properties\n :param str account: (optional) witness account name\n\n Properties:::\n\n {\n \"account_creation_fee\": \"3.000 CREA\",\n \"maximum_block_size\": 65536,\n \"sbd_interest_rate\": 0,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n\n account = Account(account, crea_instance=self)\n\n try:\n PublicKey(signing_key, prefix=self.prefix)\n except Exception as e:\n raise e\n if \"account_creation_fee\" in props:\n props[\"account_creation_fee\"] = Amount(props[\"account_creation_fee\"], crea_instance=self)\n op = operations.Witness_update(\n **{\n \"owner\": account[\"name\"],\n \"url\": url,\n \"block_signing_key\": signing_key,\n \"props\": props,\n \"fee\": Amount(0, self.crea_symbol, crea_instance=self),\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"active\", **kwargs)\n\n def _test_weights_treshold(self, authority):\n \"\"\" This method raises an error if the threshold of an authority cannot\n be reached by the weights.\n\n :param dict authority: An authority of an account\n :raises ValueError: if the threshold is set too high\n \"\"\"\n weights = 0\n for a in authority[\"account_auths\"]:\n weights += int(a[1])\n for a in authority[\"key_auths\"]:\n weights += int(a[1])\n if authority[\"weight_threshold\"] > weights:\n raise ValueError(\"Threshold too restrictive!\")\n if authority[\"weight_threshold\"] == 0:\n raise ValueError(\"Cannot have threshold of 0\")\n\n def custom_json(self,\n id,\n json_data,\n required_auths=[],\n required_posting_auths=[],\n **kwargs):\n \"\"\" Create a custom json operation\n\n :param str id: identifier for the custom json (max length 32 bytes)\n :param json json_data: the json data to put into the custom_json\n operation\n :param list required_auths: (optional) required auths\n :param list required_posting_auths: (optional) posting auths\n\n .. note:: While reqired auths and required_posting_auths are both\n optional, one of the two are needed in order to send the custom\n json.\n\n .. code-block:: python\n\n crea.custom_json(\"id\", \"json_data\",\n required_posting_auths=['account'])\n\n \"\"\"\n account = None\n if len(required_auths):\n account = required_auths[0]\n elif len(required_posting_auths):\n account = required_posting_auths[0]\n else:\n raise Exception(\"At least one account needs to be specified\")\n account = Account(account, full=False, crea_instance=self)\n op = operations.Custom_json(\n **{\n \"json\": json_data,\n \"required_auths\": required_auths,\n \"required_posting_auths\": required_posting_auths,\n \"id\": id,\n \"prefix\": self.prefix,\n })\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def post(self,\n title,\n body,\n author=None,\n permlink=None,\n reply_identifier=None,\n json_metadata=None,\n comment_options=None,\n community=None,\n app=None,\n tags=None,\n beneficiaries=None,\n self_vote=False,\n parse_body=False,\n **kwargs):\n \"\"\" Create a new post.\n If this post is intended as a reply/comment, `reply_identifier` needs\n to be set with the identifier of the parent post/comment (eg.\n `@author/permlink`).\n Optionally you can also set json_metadata, comment_options and upvote\n the newly created post as an author.\n Setting category, tags or community will override the values provided\n in json_metadata and/or comment_options where appropriate.\n\n :param str title: Title of the post\n :param str body: Body of the post/comment\n :param str author: Account are you posting from\n :param str permlink: Manually set the permlink (defaults to None).\n If left empty, it will be derived from title automatically.\n :param str reply_identifier: Identifier of the parent post/comment (only\n if this post is a reply/comment).\n :param json_metadata: JSON meta object that can be attached to\n the post.\n :type json_metadata: str, dict\n :param dict comment_options: JSON options object that can be\n attached to the post.\n\n Example::\n\n comment_options = {\n 'max_accepted_payout': '1000000.000 CBD',\n 'percent_crea_dollars': 10000,\n 'allow_votes': True,\n 'allow_curation_rewards': True,\n 'extensions': [[0, {\n 'beneficiaries': [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000},\n ]}\n ]]\n }\n\n :param str community: (Optional) Name of the community we are posting\n into. This will also override the community specified in\n `json_metadata`.\n :param str app: (Optional) Name of the app which are used for posting\n when not set, crea/<version> is used\n :param tags: (Optional) A list of tags to go with the\n post. This will also override the tags specified in\n `json_metadata`. The first tag will be used as a 'category'. If\n provided as a string, it should be space separated.\n :type tags: str, list\n :param list beneficiaries: (Optional) A list of beneficiaries\n for posting reward distribution. This argument overrides\n beneficiaries as specified in `comment_options`.\n\n For example, if we would like to split rewards between account1 and\n account2::\n\n beneficiaries = [\n {'account': 'account1', 'weight': 5000},\n {'account': 'account2', 'weight': 5000}\n ]\n\n :param bool self_vote: (Optional) Upvote the post as author, right after\n posting.\n :param bool parse_body: (Optional) When set to True, all mentioned users,\n used links and images are put into users, links and images array inside\n json_metadata. This will override provided links, images and users inside\n json_metadata. Hashtags will added to tags until its length is below five entries.\n\n \"\"\"\n\n # prepare json_metadata\n json_metadata = json_metadata or {}\n if isinstance(json_metadata, str):\n json_metadata = json.loads(json_metadata)\n\n # override the community\n if community:\n json_metadata.update({'community': community})\n if app:\n json_metadata.update({'app': app})\n elif 'app' not in json_metadata:\n json_metadata.update({'app': 'crea/%s' % (crea_version)})\n\n if not author and config[\"default_account\"]:\n author = config[\"default_account\"]\n if not author:\n raise ValueError(\"You need to provide an account\")\n account = Account(author, crea_instance=self)\n # deal with the category and tags\n if isinstance(tags, str):\n tags = list(set([_f for _f in (re.split(\"[\\W_]\", tags)) if _f]))\n\n category = None\n tags = tags or json_metadata.get('tags', [])\n\n if parse_body:\n def get_urls(mdstring):\n return list(set(re.findall('http[s]*://[^\\s\"><\\)\\(]+', mdstring)))\n\n def get_users(mdstring):\n users = []\n for u in re.findall('(^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(^|[^a-zA-Z0-9_+~.-\\/#]))[@＠]([a-z][-\\.a-z\\d]+[a-z\\d])', mdstring):\n users.append(list(u)[-1])\n return users\n\n def get_hashtags(mdstring):\n hashtags = []\n for t in re.findall('(^|\\s)(#[-a-z\\d]+)', mdstring):\n hashtags.append(list(t)[-1])\n return hashtags\n\n users = []\n image = []\n links = []\n for url in get_urls(body):\n img_exts = ['.jpg', '.png', '.gif', '.svg', '.jpeg']\n if os.path.splitext(url)[1].lower() in img_exts:\n image.append(url)\n else:\n links.append(url)\n users = get_users(body)\n hashtags = get_hashtags(body)\n users = list(set(users).difference(set([author])))\n if len(users) > 0:\n json_metadata.update({\"users\": users})\n if len(image) > 0:\n json_metadata.update({\"image\": image})\n if len(links) > 0:\n json_metadata.update({\"links\": links})\n if len(tags) < 5:\n for i in range(5 - len(tags)):\n if len(hashtags) > i:\n tags.append(hashtags[i])\n\n if tags:\n # first tag should be a category\n category = tags[0]\n json_metadata.update({\"tags\": tags})\n\n # can't provide a category while replying to a post\n if reply_identifier and category:\n category = None\n\n # deal with replies/categories\n if reply_identifier:\n parent_author, parent_permlink = resolve_authorperm(\n reply_identifier)\n if not permlink:\n permlink = derive_permlink(title, parent_permlink)\n elif category:\n parent_permlink = derive_permlink(category)\n parent_author = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n else:\n parent_author = \"\"\n parent_permlink = \"\"\n if not permlink:\n permlink = derive_permlink(title)\n\n post_op = operations.Comment(\n **{\n \"parent_author\": parent_author,\n \"parent_permlink\": parent_permlink,\n \"author\": account[\"name\"],\n \"permlink\": permlink,\n \"title\": title,\n \"body\": body,\n \"json_metadata\": json_metadata\n })\n ops = [post_op]\n\n # if comment_options are used, add a new op to the transaction\n if comment_options or beneficiaries:\n comment_op = self._build_comment_options_op(account['name'],\n permlink,\n comment_options,\n beneficiaries)\n ops.append(comment_op)\n\n if self_vote:\n vote_op = operations.Vote(\n **{\n 'voter': account[\"name\"],\n 'author': account[\"name\"],\n 'permlink': permlink,\n 'weight': CREA_100_PERCENT,\n })\n ops.append(vote_op)\n\n return self.finalizeOp(ops, account, \"posting\", **kwargs)\n\n def comment_options(self, options, identifier, beneficiaries=[],\n account=None, **kwargs):\n \"\"\" Set the comment options\n\n :param dict options: The options to define.\n :param str identifier: Post identifier\n :param list beneficiaries: (optional) list of beneficiaries\n :param str account: (optional) the account to allow access\n to (defaults to ``default_account``)\n\n For the options, you have these defaults:::\n\n {\n \"author\": \"\",\n \"permlink\": \"\",\n \"max_accepted_payout\": \"1000000.000 CBD\",\n \"percent_crea_dollars\": 10000,\n \"allow_votes\": True,\n \"allow_curation_rewards\": True,\n }\n\n \"\"\"\n if not account and config[\"default_account\"]:\n account = config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account, crea_instance=self)\n author, permlink = resolve_authorperm(identifier)\n op = self._build_comment_options_op(author, permlink, options,\n beneficiaries)\n return self.finalizeOp(op, account, \"posting\", **kwargs)\n\n def _build_comment_options_op(self, author, permlink, options,\n beneficiaries):\n options = remove_from_dict(options or {}, [\n 'max_accepted_payout', 'percent_crea_dollars',\n 'allow_votes', 'allow_curation_rewards', 'extensions'\n ], keep_keys=True)\n # override beneficiaries extension\n if beneficiaries:\n # validate schema\n # or just simply vo.Schema([{'account': str, 'weight': int}])\n\n weight_sum = 0\n for b in beneficiaries:\n if 'account' not in b:\n raise ValueError(\n \"beneficiaries need an account field!\"\n )\n if 'weight' not in b:\n b['weight'] = CREA_100_PERCENT\n if len(b['account']) > 16:\n raise ValueError(\n \"beneficiaries error, account name length >16!\"\n )\n if b['weight'] < 1 or b['weight'] > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries error, 1<=weight<=%s!\" %\n (CREA_100_PERCENT)\n )\n weight_sum += b['weight']\n\n if weight_sum > CREA_100_PERCENT:\n raise ValueError(\n \"beneficiaries exceed total weight limit %s\" %\n CREA_100_PERCENT\n )\n\n options['beneficiaries'] = beneficiaries\n\n default_max_payout = \"1000000.000 %s\" % (self.sbd_symbol)\n comment_op = operations.Comment_options(\n **{\n \"author\":\n author,\n \"permlink\":\n permlink,\n \"max_accepted_payout\":\n options.get(\"max_accepted_payout\", default_max_payout),\n \"percent_crea_dollars\":\n int(options.get(\"percent_crea_dollars\", CREA_100_PERCENT)),\n \"allow_votes\":\n options.get(\"allow_votes\", True),\n \"allow_curation_rewards\":\n options.get(\"allow_curation_rewards\", True),\n \"extensions\":\n options.get(\"extensions\", []),\n \"beneficiaries\":\n options.get(\"beneficiaries\", []),\n \"prefix\": self.prefix,\n })\n return comment_op\n\n def get_api_methods(self):\n \"\"\"Returns all supported api methods\"\"\"\n return self.rpc.get_methods(api=\"jsonrpc\")\n\n def get_apis(self):\n \"\"\"Returns all enabled apis\"\"\"\n api_methods = self.get_api_methods()\n api_list = []\n for a in api_methods:\n api = a.split(\".\")[0]\n if api not in api_list:\n api_list.append(api)\n return api_list\n\n def _get_asset_symbol(self, asset_id):\n \"\"\" get the asset symbol from an asset id\n\n :@param int asset_id: 0 -> CBD, 1 -> CREA, 2 -> VESTS\n\n \"\"\"\n for asset in self.chain_params['chain_assets']:\n if asset['id'] == asset_id:\n return asset['symbol']\n\n raise KeyError(\"asset ID not found in chain assets\")\n\n @property\n def sbd_symbol(self):\n \"\"\" get the current chains symbol for CBD (e.g. \"TBD\" on testnet) \"\"\"\n # some networks (e.g. whaleshares) do not have CBD\n try:\n symbol = self._get_asset_symbol(0)\n except KeyError:\n symbol = self._get_asset_symbol(1)\n return symbol\n\n @property\n def crea_symbol(self):\n \"\"\" get the current chains symbol for CREA (e.g. \"TESTS\" on testnet) \"\"\"\n return self._get_asset_symbol(1)\n\n @property\n def vests_symbol(self):\n \"\"\" get the current chains symbol for VESTS \"\"\"\n return self._get_asset_symbol(2)\n"}}},{"rowIdx":2099,"cells":{"function_name":{"kind":"string","value":"check_closed_path"},"docstring":{"kind":"string","value":"Checks that data is not changed for the first closed path found. Returns True if data==data after\nmoving around the closed path, False otherwise. Starting point is current_node "},"masked_code":{"kind":"string","value":"#-----------------------------------------------------------------------------\n# Name: GraphModels\n# Purpose: To store graphs used in network translations\n# Author: Aric Sanders\n# Created: 4/6/2016\n# License: MIT License\n#-----------------------------------------------------------------------------\n\"\"\"\nGraph Models stores sub classes of graphs that define data translations. All edges\nor the functions that define translations from one format to another\nare found in <a href=\"./Translations.m.html\">`pyMez.Code.DataHandlers.Translations`</a>.\nCurrently, the module networkx is used to display the graph.\n\nExamples\n--------\n #!python\n >>from pyMez import *\n >>image_graph=ImageGraph()\n >>image_graph.set_state('png','my_png.png')\n >>image_graph.move_to_node('EmbeddedHtml')\n >>output=image_graph.data\n >>print output\n\n\n<h3><a href=\"../../../Examples/Html/GraphModels_Example.html\">GraphModels Example</a></h3>\n\nRequirements\n------------\n+ [sys](https://docs.python.org/2/library/sys.html)\n+ [os](https://docs.python.org/2/library/os.html?highlight=os#module-os)\n+ [networkx](http://networkx.github.io/)\n+ [numpy](http://www.numpy.org/)\n+ [pyMez](https://github.com/aricsanders/pyMez)\n\nHelp\n---------------\n<a href=\"./index.html\">`pyMez.Code.DataHandlers`</a>\n<div>\n<a href=\"../../../pyMez_Documentation.html\">Documentation Home</a> |\n<a href=\"../../index.html\">API Documentation Home</a> |\n<a href=\"../../../Examples/html/Examples_Home.html\">Examples Home</a> |\n<a href=\"../../../Reference_Index.html\">Index</a>\n</div>\n \"\"\"\n\n#-----------------------------------------------------------------------------\n# Standard Imports\nimport re\nimport datetime\nimport sys\nimport os\n\n#-----------------------------------------------------------------------------\n# Third Party Imports\nsys.path.append(os.path.join(os.path.dirname( __file__ ), '..','..'))\ntry:\n from Code.Utils.Alias import *\n METHOD_ALIASES=1\nexcept:\n print(\"The module pyMez.Code.Utils.Alias was not found\")\n METHOD_ALIASES=0\n pass\ntry:\n from Code.DataHandlers.GeneralModels import *\nexcept:\n print(\"The module pyMez.Code.DataHandlers.GeneralModels was not found,\"\n \"please put it on the python path\")\n raise ImportError\ntry:\n from Code.DataHandlers.TouchstoneModels import *\nexcept:\n print(\"The module pyMez.Code.DataHandlers.TouchstoneModels was not found,\"\n \"please put it on the python path\")\n raise ImportError\ntry:\n from Code.DataHandlers.Translations import *\nexcept:\n print(\"The module pyMez.Code.DataHandlers.Translations was not found or had an error,\"\n \"please put it on the python path or resolve the error\")\n raise ImportError\ntry:\n import numpy as np\nexcept:\n print(\"The module numpy was not found,\"\n \"please put it on the python path\")\n raise ImportError\ntry:\n import networkx\nexcept:\n print(\"The module networkx was not found,\"\n \"please put it on the python path\")\n raise ImportError\n\n#-----------------------------------------------------------------------------\n# Module Constants\n\n#-----------------------------------------------------------------------------\n# Module Functions\n\n# as an example these functions are left.\n#todo: Change the names\ndef edge_1_to_2(in_string):\n \"A Test function for an edge for a Graph\"\n return in_string.splitlines()\n\ndef edge_2_to_1(string_list):\n \"\"\"A test function for an edge in a Graph\"\"\"\n return string_list_collapse(string_list)\n\ndef visit_all_nodes(graph):\n \"\"\"Visit all nodes visits each node on a graph\"\"\"\n nodes=graph.node_names\n for node in nodes:\n graph.move_to_node(node)\n\ndef visit_and_print_all_nodes(graph):\n \"\"\"Visits all the nodes in graph and prints graph.data after each move\"\"\"\n nodes=graph.node_names\n for node in nodes:\n graph.move_to_node(node)\n print((graph.data))\n\n\ndef to_node_name(node_data):\n \"\"\"Creates a node name given an input object, does a bit of silly type selecting and name rearranging. This matches for 75%\n of the cases. There are a lot of user defined nodes without a clear path to generate a name. For instance the DataTableGraph\n node HpFile, does not save with a .hp extension so it would be auto named TxtFile if was only selected by the path name.\n If it is auto selected it returns StringList because it is of the format [\"file_path\",\"schema_path\"] \"\"\"\n\n # we retrieve the text version of the class name\n class_name = node_data.__class__.__name__\n node_name = class_name\n # now for dict and list types we want to inspect the first Element to see what it is\n if re.match('list', class_name):\n node_name = \"List\"\n try:\n element_class_name = node_data[0].__class__.__name__\n node_name = element_class_name + node_name\n except:\n pass\n elif re.match('dict', class_name):\n node_name = \"Dictionary\"\n try:\n element_class_name = list(node_data.values())[0].__class__.__name__\n node_name = element_class_name + node_name\n except:\n pass\n elif re.match('str', class_name):\n node_name = \"String\"\n # Now we have to check if it is an existing file name\n if os.path.isfile(node_data):\n node_name = \"File\"\n extension = \"\"\n try:\n if re.search(\"\\.\", node_data):\n extension = node_data.split(\".\")[-1]\n node_name = extension.title() + node_name\n except:\n pass\n elif fnmatch.fnmatch(node_data, \"*.*\"):\n node_name = \"File\"\n try:\n if re.search(\"\\.\", node_data):\n extension = node_data.split(\".\")[-1]\n node_name = extension.title() + node_name\n except:\n pass\n node_name = node_name.replace(\"str\", \"String\").replace(\"dict\", \"Dictionary\")\n return (node_name)\n\n\ndef TableGraph_to_Links(table_graph, **options):\n \"\"\"Converts a table graph to a set of download links with embedded data in them\"\"\"\n defaults = {\"base_name\": None,\n \"nodes\": ['XmlFile', 'CsvFile', 'ExcelFile', 'OdsFile', 'MatFile', 'HtmlFile', 'JsonFile'],\n \"extensions\": ['xml', 'csv', 'xlsx', 'ods', 'mat', 'html', 'json'],\n \"mime_types\": ['application/xml', 'text/plain',\n 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n 'application/vnd.oasis.opendocument.spreadsheet',\n 'application/x-matlab-data', 'text/html', 'application/json']}\n conversion_options = {}\n for key, value in defaults.items():\n conversion_options[key] = value\n for key, value in options.items():\n conversion_options[key] = value\n if conversion_options[\"base_name\"] is None:\n base_name = 'test.txt'\n else:\n base_name = conversion_options[\"base_name\"]\n\n nodes = conversion_options[\"nodes\"]\n extensions = conversion_options[\"extensions\"]\n mime_types = conversion_options[\"mime_types\"]\n\n out_links = \"\"\n for node_index, node in enumerate(nodes):\n table_graph.move_to_node(node)\n file_path = table_graph.data\n in_file = open(file_path, 'rb')\n content_string = in_file.read()\n link = String_to_DownloadLink(content_string,\n suggested_name=change_extension(base_name, extensions[node_index]),\n mime_type=mime_types[node_index],\n text=extensions[node_index])\n if node_index == len(nodes) - 1:\n out_links = out_links + link\n else:\n out_links = out_links + link + \" | \"\n return out_links\n\n\ndef remove_circular_paths(path):\n \"\"\"Removes pieces of the path that just end on the same node\"\"\"\n # Todo: Track the error that leaves out a needed path sometimes\n # See http://localhost:8888/notebooks/Two_Port_Matrix_Parameters_Debug_20170105_001.ipynb\n\n edge_pattern=re.compile(\"edge_(?P<begin_node>\\w+)_(?P<end_node>\\w+)_(?P<iterator>\\w+)\")\n past_locations=[]\n\n for index,edge in enumerate(path):\n match=re.match(edge_pattern,edge)\n begin_node=match.groupdict()[\"begin_node\"]\n end_node=match.groupdict()[\"end_node\"]\n past_locations.append(begin_node)\n #print(\"{0} is {1}\".format(\"past_locations\",past_locations))\n new_path=[]\n node_index=0\n between_list=[False for item in past_locations]\n while(node_index<len(past_locations)):\n node=past_locations[node_index]\n old_path=new_path\n new_path=[]\n # if you visit a location more than one\n number_of_visits=past_locations.count(node)\n if number_of_visits>1:\n #print(\"{0} is {1}\".format(\"node\",node))\n #print(\"{0} is {1}\".format(\"past_locations\",past_locations))\n # Now find all the visits to that location\n equality_list=[x==node for x in past_locations]\n print((\"{0} is {1}\".format(\"equality_list\",equality_list)))\n # You are intially not between visits\n between=False\n\n # every time you cross that node you flip between, as long as there are\n visit_number=0\n for index,equality in enumerate(equality_list):\n if equality:\n # add one to the visit number\n visit_number+=1\n # Flip the between truth value if it is the first or last\n # visits only\n if visit_number==1 or visit_number==number_of_visits:\n between=not between\n between_list[index]=between or between_list[index]\n else:\n between_list[index]=between or between_list[index]\n else:\n between_list[index]=between or between_list[index]\n #print(\"{0} is {1}\".format(\"between_list\",between_list))\n for index,item in enumerate(between_list):\n if not item:\n new_path.append(path[index])\n node_index+=1\n if new_path in [[]]:\n new_path=path\n return new_path\n#-----------------------------------------------------------------------------\n# Module Classes\n\n# getting around to adding a breadth first graph solver to Graph class\n# modify the find_path method\nclass Graph(object):\n \"\"\"The Graph class creates a content graph that has as nodes different formats. As\n a format is added via graph.add_node() by specifying a node name and a function from an\n existing node into the new one, and one exiting the node. Once a series of nodes exists\n to enter the graph at a node use graph.set_state() the current data representing the\n state is in the attribute graph.data. To move among the formats use graph.move_to_node('NodeName')\n need to recode the find_path method using a shortest path alogrithm like\n [Dijkstra](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm).\n \"\"\"\n\n def __init__(self, **options):\n \"\"\"Initializes the graph. The first 2 nodes and two edges forming a bijection between them are required\"\"\"\n defaults = {\"graph_name\": \"Graph\",\n \"node_names\": ['n1', 'n2'],\n \"node_descriptions\": [\"A plain string\",\n \"A list of strings with no \\\\n, created with string.splitlines()\"],\n \"current_node\": 'n1',\n \"state\": [1, 0],\n \"data\": \"This is a test string\\n it has to have multiple lines \\n and many characters 34%6\\n^\",\n \"edge_2_to_1\": edge_2_to_1,\n \"edge_1_to_2\": edge_1_to_2\n }\n self.options = {}\n for key, value in defaults.items():\n self.options[key] = value\n for key, value in options.items():\n self.options[key] = value\n self.elements = ['graph_name', 'node_names', 'node_descriptions', 'current_node', 'state', 'data']\n for element in self.elements:\n self.__dict__[element] = self.options[element]\n self.edges = []\n self.edge_matrices = []\n self.state_matrix = np.matrix(self.state).T\n # Add the first 2 edges, required to intialize the graph properly\n self.display_graph = networkx.DiGraph()\n\n self.add_edge(self.node_names[0], self.node_names[1], self.options[\"edge_1_to_2\"])\n self.add_edge(self.node_names[1], self.node_names[0], self.options[\"edge_2_to_1\"])\n self.jumps = []\n self.external_node_names = []\n self.external_node_descriptions = []\n self.display_layout = networkx.spring_layout(self.display_graph)\n\n def get_description_dictionary(self):\n \"returns a dictionary of the form {NodeName:Node Description for all of the current nodes\"\n dictionary = {node_name: self.node_descriptions[index] for index, node_name in enumerate(self.node_names)}\n return dictionary\n\n def set_state(self, node_name, node_data):\n \"\"\"Sets the graph state to be the state specified by node_name, and node_data\"\"\"\n try:\n current_node_state_position = self.node_names.index(node_name)\n self.current_node = node_name\n self.data = node_data\n self.state = [0 for i in range(len(self.node_names))]\n self.state[current_node_state_position] = 1\n self.state_matrix = np.matrix(self.state).T\n except:\n print((\"Could not set the state of graph: {0}\".format(self.graph_name)))\n raise\n\n def add_edge(self, begin_node=None, end_node=None, edge_function=None):\n \"\"\"Adds an edge mapping one node to another, required input is begin_node (it's name)\n end_node, and the edge function\"\"\"\n # check to see if edge is defined if it is increment a number\n edge_match = re.compile(\"edge_{0}_{1}\".format(begin_node, end_node))\n keys = list(self.__dict__.keys())\n # print keys\n iterator = 0\n for key in keys:\n if re.match(edge_match, key):\n iterator += 1\n edge_name = \"edge_{0}_{1}_{2:0>3d}\".format(begin_node, end_node, iterator)\n self.__dict__[edge_name] = edge_function\n self.edges.append(edge_name)\n edge_matrix = np.zeros((len(self.state), len(self.state)))\n begin_position = self.node_names.index(begin_node)\n end_position = self.node_names.index(end_node)\n edge_matrix[end_position][begin_position] = 1\n edge_matrix = np.matrix(edge_matrix)\n self.edge_matrices.append(edge_matrix)\n self.display_graph.add_edge(begin_node, end_node)\n self.display_layout = networkx.spring_layout(self.display_graph)\n\n def add_jump(self, begin_node=None, end_node=None, jump_function=None):\n \"\"\"Adds a jump mapping one internal node to an external node, required input is begin_node (it's name)\n end_node, and the edge function\"\"\"\n # check to see if edge is defined if it is increment a number\n jump_match = re.compile(\"jump_{0}_{1}\".format(begin_node, end_node))\n keys = list(self.__dict__.keys())\n # print keys\n iterator = 0\n for key in keys:\n if re.match(jump_match, key):\n iterator += 1\n jump_name = \"jump_{0}_{1}_{2:0>3d}\".format(begin_node, end_node, iterator)\n self.__dict__[jump_name] = jump_function\n self.jumps.append(jump_name)\n self.display_graph.add_edge(begin_node, end_node)\n self.display_layout = networkx.spring_layout(self.display_graph)\n\n def move_to(self, path, **options):\n \"\"\"Changes the state of the graph by moving along the path specified\"\"\"\n defaults = {\"debug\": False, \"verbose\": False}\n move_options = {}\n for key, value in defaults.items():\n move_options[key] = value\n for key, value in options.items():\n move_options[key] = value\n\n if move_options[\"debug\"]:\n print(path)\n for index, edge in enumerate(path):\n # print edge\n edge_pattern = 'edge_(?P<begin_node>\\w+)_(?P<end_node>\\w+)_(?P<iterator>\\w+)'\n match = re.match(edge_pattern, edge)\n begin_node = match.groupdict()['begin_node']\n end_node = match.groupdict()['end_node']\n if move_options[\"verbose\"]:\n print((\"moving {0} -> {1}\".format(begin_node, end_node)))\n # print self.data\n self.data = self.__dict__[edge](self.data)\n # print self.data\n self.current_node = match.groupdict()['end_node']\n self.state = [0 for i in range(len(self.node_names))]\n position = self.node_names.index(self.current_node)\n self.state[position] = 1\n self.state_matrix = np.matrix(self.state).T\n # print self.state\n # print self.current_node\n\n def virtual_move_to(self, path):\n \"\"\"virtual_move_to simulates moving but does not change the state of the graph\"\"\"\n # print path\n temp_state = self.state\n temp_data = self.data\n temp_current_node = self.current_node\n temp_node_names = self.node_names\n for index, edge in enumerate(path):\n # print edge\n edge_pattern = 'edge_(?P<begin_node>\\w+)_(?P<end_node>\\w+)_(?P<iterator>\\w+)'\n match = re.match(edge_pattern, edge)\n begin_node = match.groupdict()['begin_node']\n end_node = match.groupdict()['end_node']\n # print(\"moving {0} -> {1}\".format(begin_node,end_node))\n # print self.data\n temp_data = self.__dict__[edge](temp_data)\n # print self.data\n temp_current_node = match.groupdict()['end_node']\n temp_state = [0 for i in range(len(temp_node_names))]\n position = temp_node_names.index(temp_current_node)\n temp_state[position] = 1\n # print temp_state\n # print self.state\n # print self.current_node\n\n def __str__(self):\n return str(self.data)\n\n def add_node(self, node_name, edge_into_node_begin, edge_into_node_function, edge_out_node_end,\n edge_out_node_function, node_description=None):\n \"\"\"Adds a node to the graph. Required input is node_name (a string with no spaces),\n a reference to an entering node,the function mapping the entering node to the new node,\n a reference to an exiting node and the function mapping the\n new node to the exiting node.\"\"\"\n # first check if node into and out of node is good\n self.node_names.append(node_name)\n self.state.append(0)\n self.state_matrix = np.matrix(self.state).T\n for index, matrix in enumerate(self.edge_matrices):\n pad_row = np.zeros((1, len(matrix)))\n new_matrix = np.concatenate((matrix, pad_row), axis=0)\n pad_column = np.zeros((1, len(self.node_names)))\n new_matrix = np.concatenate((new_matrix, pad_column.T), axis=1)\n # print(\"New matrix is :\\n{0}\".format(new_matrix))\n self.edge_matrices[index] = new_matrix\n self.add_edge(begin_node=node_name, end_node=edge_out_node_end, edge_function=edge_out_node_function)\n self.add_edge(begin_node=edge_into_node_begin, end_node=node_name, edge_function=edge_into_node_function)\n if node_description:\n self.node_descriptions.append(node_description)\n self.display_graph.add_node(node_name)\n self.display_graph.add_edge(node_name, edge_out_node_end)\n self.display_graph.add_edge(edge_into_node_begin, node_name)\n self.display_layout = networkx.spring_layout(self.display_graph)\n\n def add_external_node(self, external_node_name, jump_into_node_begin,\n jump_into_node_function, external_node_description=None):\n \"\"\"Adds an external node to the graph. Required input is node_name (a string with no spaces),\n a reference to an entering node,the function mapping the entering node to the new external node\"\"\"\n # first check if node into and out of node is good\n self.external_node_names.append(external_node_name)\n self.add_jump(begin_node=jump_into_node_begin, end_node=external_node_name,\n jump_function=jump_into_node_function)\n if external_node_description:\n self.external_node_descriptions.append(external_node_description)\n self.display_graph.add_node(external_node_name)\n self.display_graph.add_edge(jump_into_node_begin, external_node_name)\n self.display_layout = networkx.spring_layout(self.display_graph)\n\n def jump_to_external_node(self, external_node_name, **options):\n \"\"\"Returns the result of the jump, the graph is left in the node that is the begining of the jump\"\"\"\n end_node = external_node_name\n jump_pattern = 'jump_(?P<begin_node>\\w+)_{0}_(?P<iterator>\\w+)'.format(end_node)\n for jump in self.jumps[:]:\n jump_match = re.match(jump_pattern, jump, re.IGNORECASE)\n if jump_match:\n jump_to_use = jump\n begin_node = jump_match.groupdict()[\"begin_node\"]\n\n self.move_to_node(begin_node)\n return self.__dict__[jump_to_use](self.data, **options)\n\n def path_length(self, path, num_repeats=10):\n \"\"\"Determines the length of a given path, currently the metric is based on the time to move to.\"\"\"\n begin_time = datetime.datetime.now()\n # num_repeats=100\n for i in range(num_repeats):\n self.virtual_move_to(path)\n end_time = datetime.datetime.now()\n delta_t = end_time - begin_time\n path_length = delta_t.total_seconds() / float(num_repeats)\n if path_length == 0.0:\n print(\"Warning the path length is less than 1 microsecond,\"\n \"make sure num_repeats is high enough to measure it.\")\n return path_length\n\n def is_path_valid(self, path):\n \"\"\"Returns True if the path is valid from the current node position or False otherwise\"\"\"\n null_state = [0 for i in range(len(self.node_names))]\n null_state_matrix = np.matrix(null_state).T\n new_state = np.matrix(self.state).T\n for index, edge in enumerate(path):\n # print index\n # print edge\n edge_position = self.edges.index(edge)\n move_matrix = self.edge_matrices[edge_position]\n # print move_matrix\n new_state = move_matrix * new_state\n if new_state.any() == null_state_matrix.any():\n # print new_state\n # print null_state_matrix\n return False\n return True\n\n def get_entering_nodes(self, node):\n \"\"\"Returns all nodes that have an edge that enter the specificed node\"\"\"\n enter_edge_pattern = re.compile('edge_(?P<begin_node>\\w+)_{0}_(?P<iterator>\\w+)'.format(node))\n enter_nodes = []\n for index, edge in enumerate(self.edges):\n enter_match = re.match(enter_edge_pattern, edge)\n if enter_match:\n enter_node = enter_match.groupdict()['begin_node']\n enter_nodes.append(enter_node)\n return enter_nodes\n\n def get_entering_edges(self, node):\n \"\"\"Returns all edges that enter the specificed node\"\"\"\n enter_edge_pattern = re.compile('edge_(?P<begin_node>\\w+)_{0}_(?P<iterator>\\w+)'.format(node))\n enter_edges = []\n for index, edge in enumerate(self.edges):\n if re.match(enter_edge_pattern, edge):\n enter_edges.append(edge)\n return enter_edges\n\n def get_exiting_edges(self, node):\n \"\"\"Returns all edges that exit the specificed node\"\"\"\n exit_edge_pattern = re.compile('edge_{0}_(?P<end_node>\\w+)_(?P<iterator>\\w+)'.format(node))\n exit_edges = []\n for index, edge in enumerate(self.edges):\n if re.match(exit_edge_pattern, edge):\n exit_edges.append(edge)\n return exit_edges\n\n def get_exiting_nodes(self, node):\n \"\"\"Returns all nodes that have an edge leaving the specificed node\"\"\"\n exit_edge_pattern = re.compile('edge_{0}_(?P<end_node>\\w+)_(?P<iterator>\\w+)'.format(node))\n exit_nodes = []\n for index, edge in enumerate(self.edges):\n exit_match = re.match(exit_edge_pattern, edge)\n if exit_match:\n exit_node = exit_match.groupdict()['end_node']\n exit_nodes.append(exit_node)\n return exit_nodes\n\n def get_path(self, first_node, last_node, **options):\n \"\"\"Returns the first path found between first node and last node, uses a breadth first search algorithm\"\"\"\n defaults = {\"debug\": False, \"method\": \"BreathFirst\"}\n self.get_path_options = {}\n for key, value in defaults.items():\n self.get_path_options[key] = value\n for key, value in options.items():\n self.get_path_options[key] = value\n unvisited_nodes = self.node_names[:]\n unvisited_nodes.remove(first_node)\n visited_nodes = [first_node]\n node_history = []\n edge_history = []\n path_queue = []\n possible_paths = []\n queue = []\n current_edge = []\n queue.append(first_node)\n path = {first_node: []}\n while queue:\n # first remove the\n current_node = queue.pop(0)\n if path_queue != []:\n current_edge = path_queue.pop(0)\n edge_history.append(current_edge)\n node_history.append(current_node)\n if self.get_path_options[\"debug\"]:\n print((\"current_node is {0}\".format(current_node)))\n print((\"current_edge is {0}\".format(current_edge)))\n # if this node is the destination exit returning the path\n if current_node == last_node:\n if self.get_path_options[\"debug\"]:\n print((\"Node path was found to be {0}\".format(node_path)))\n print((\"path was found to be {0}\".format(edge_path)))\n print((\"{0} is {1}\".format(\"path\", path)))\n return path[last_node][::-1]\n\n adjacent_nodes = self.get_exiting_nodes(current_node)\n adjacent_paths = self.get_exiting_edges(current_node)\n if self.get_path_options[\"debug\"]:\n print((\"{0} are {1}\".format(\"adjacent_nodes\", adjacent_nodes)))\n print((\"{0} are {1}\".format(\"adjacent_paths\", adjacent_paths)))\n current_history = edge_history\n for node_index, node in enumerate(adjacent_nodes):\n if node not in visited_nodes:\n queue.append(node)\n path_queue.append(adjacent_paths[node_index])\n visited_nodes.append(node)\n path[node] = [adjacent_paths[node_index]] + path[current_node]\n path[node]\n # possible_paths.append(current_path.append(node))\n if self.get_path_options[\"debug\"]:\n print((\"{0} is {1}\".format(\"path_queue\", path_queue)))\n\n def move_to_node(self, node):\n \"\"\"Moves from current_node to the specified node\"\"\"\n path = self.get_path(self.current_node, node)\n self.move_to(path)\n\n# MASKED: check_closed_path function (lines 615-629)\n\n def is_graph_isomorphic(self):\n \"\"\"Returns True if all nodes have closed paths that preserve the data, False otherwise\"\"\"\n out = True\n for node in self.node_names:\n self.move_to_node(node)\n if not self.check_closed_path:\n out = False\n return out\n\n def show(self, **options):\n \"\"\"Shows the graph using matplotlib and networkx\"\"\"\n # Should be seperated to allow for fixed presentation?\n defaults = {\"descriptions\": False, \"edge_descriptions\": False, \"save_plot\": False,\n \"path\": None, \"active_node\": True, \"directory\": None,\n \"specific_descriptor\": self.graph_name.replace(\" \", \"_\"),\n \"general_descriptor\": \"plot\", \"file_name\": None,\n \"arrows\": True, \"node_size\": 1000, \"font_size\": 10, \"fix_layout\": True}\n show_options = {}\n for key, value in defaults.items():\n show_options[key] = value\n for key, value in options.items():\n show_options[key] = value\n if show_options[\"directory\"] is None:\n show_options[\"directory\"] = os.getcwd()\n if show_options[\"active_node\"]:\n node_colors = []\n for node in self.display_graph.nodes():\n if node == self.current_node:\n node_colors.append('b')\n else:\n if node in self.node_names:\n node_colors.append('r')\n elif node in self.external_node_names:\n node_colors.append('g')\n else:\n node_colors = ['r' for node in self.node_names] + ['g' for node in self.node_names]\n # print(\"{0} is {1}\".format('node_colors',node_colors))\n if show_options[\"descriptions\"]:\n node_labels = {node: self.node_descriptions[index] for index,\n node in enumerate(self.node_names)}\n if self.external_node_names:\n for index, node in enumerate(self.external_node_names):\n node_labels[node] = self.external_node_descriptions[index]\n networkx.draw_networkx(self.display_graph, arrows=show_options[\"arrows\"],\n labels=node_labels, node_color=node_colors,\n node_size=show_options[\"node_size\"], font_size=show_options[\"font_size\"],\n pos=self.display_layout)\n # print(\"{0} is {1}\".format('node_labels',node_labels))\n else:\n networkx.draw_networkx(self.display_graph, arrows=show_options[\"arrows\"], node_color=node_colors,\n node_size=show_options[\"node_size\"], font_size=show_options[\"font_size\"],\n pos=self.display_layout)\n plt.axis('off')\n plt.suptitle(self.options[\"graph_name\"])\n if show_options[\"file_name\"] is None:\n file_name = auto_name(specific_descriptor=show_options[\"specific_descriptor\"],\n general_descriptor=show_options[\"general_descriptor\"],\n directory=show_options[\"directory\"], extension='png', padding=3)\n else:\n file_name = show_options[\"file_name\"]\n if show_options[\"save_plot\"]:\n # print file_name\n if show_options[\"path\"]:\n plt.savefig(show_options[\"path\"])\n else:\n plt.savefig(os.path.join(show_options[\"directory\"], file_name))\n else:\n plt.show()\n fig = plt.gcf()\n return fig\n\n\n\nclass StringGraph(Graph):\n \"\"\"String Graph is a graph relating different string forms\"\"\"\n def __init__(self,**options):\n \"\"\"Intializes the StringGraph Class by defining nodes and edges\"\"\"\n defaults={\"graph_name\":\"StringGraph\",\n \"node_names\":['String','StringList'],\n \"node_descriptions\":[\"A plain string\",\n \"A list of strings with no \\\\n, created with string.splitlines()\"],\n \"current_node\":'String',\n \"state\":[1,0],\n \"data\":\"This is a test string\\n it has to have multiple lines \\n and many characters 34%6\\n^\",\n \"edge_2_to_1\":edge_2_to_1,\n \"edge_1_to_2\":edge_1_to_2\n }\n self.options={}\n for key,value in defaults.items():\n self.options[key]=value\n for key,value in options.items():\n self.options[key]=value\n Graph.__init__(self,**self.options)\n self.add_node(\"File\",\"String\",String_to_File,\"String\",File_to_String,node_description=\"Plain File\")\n self.add_node(\"CStringIo\",\"String\",String_to_CStringIo,\"String\",CStringIo_to_String,node_description=\"C File Like Object\")\n self.add_node(\"StringIo\",\"String\",String_to_StringIo,\"String\",StringIo_to_String,node_description=\"File Like Object\")\n self.add_edge(begin_node=\"StringList\",end_node=\"File\",edge_function=StringList_to_File)\n\n\n# Changed from ColumnModeledGraph to TableGraph 12/14/2016 by AWS\nclass TableGraph(Graph):\n \"\"\"Class that transforms column modeled data (table) from one format to another, use set_state to initialize to\n your data.\n #!python\n defaults={\"graph_name\":\"Table Graph\",\n \"node_names\":['DataFrame','AsciiDataTable'],\n \"node_descriptions\":[\"Pandas Data Frame\",\"AsciiDataTable\"],\n \"current_node\":'DataFrame',\n \"state\":[1,0],\n \"data\":pandas.DataFrame([[1,2,3],[3,4,5]],columns=[\"a\",\"b\",\"c\"]),\n \"edge_2_to_1\":AsciiDataTable_to_DataFrame,\n \"edge_1_to_2\":DataFrame_to_AsciiDataTable}\n \"\"\"\n def __init__(self,**options):\n defaults={\"graph_name\":\"Table Graph\",\n \"node_names\":['DataFrame','AsciiDataTable'],\n \"node_descriptions\":[\"Pandas Data Frame\",\"AsciiDataTable\"],\n \"current_node\":'DataFrame',\n \"state\":[1,0],\n \"data\":pandas.DataFrame([[1,2,3],[3,4,5]],columns=[\"a\",\"b\",\"c\"]),\n \"edge_2_to_1\":AsciiDataTable_to_DataFrame,\n \"edge_1_to_2\":DataFrame_to_AsciiDataTable}\n self.options={}\n for key,value in defaults.items():\n self.options[key]=value\n for key,value in options.items():\n self.options[key]=value\n Graph.__init__(self,**self.options)\n self.add_node(\"HdfFile\",\"DataFrame\",DataFrame_to_HdfFile,\n \"DataFrame\",HdfFile_to_DataFrame,\n node_description=\"HDF File\")\n self.add_node(\"XmlDataTable\",\"AsciiDataTable\",AsciiDataTable_to_XmlDataTable,\n \"AsciiDataTable\",XmlDataTable_to_AsciiDataTable,\n node_description=\"XML Data Table\")\n # Need to add XML File and Html File using save and save_HTML()\n self.add_node(\"ExcelFile\",\"DataFrame\",DataFrame_to_ExcelFile,\n \"DataFrame\",ExcelFile_to_DataFrame,\n node_description=\"Excel File\")\n\n self.add_node(\"OdsFile\",\"ExcelFile\",ExcelFile_to_OdsFile,\n \"ExcelFile\",OdsFile_to_ExcelFile,\"Open Office Spreadsheet\")\n\n self.add_node(\"HtmlString\",\"DataFrame\",DataFrame_to_HtmlString,\n \"DataFrame\",HtmlString_to_DataFrame,\n node_description=\"HTML String\")\n # Note a lot of the pandas reading and writing cause float64 round off errors\n # applymap(lambda x: np.around(x,10) any all float fields will fix this\n # also the column names move about in order\n self.add_node(\"JsonFile\",\"DataFrame\",DataFrame_to_JsonFile,\n \"DataFrame\",JsonFile_to_DataFrame,\n node_description=\"JSON File\")\n self.add_node(\"JsonString\",\"DataFrame\",DataFrame_to_JsonString,\n \"DataFrame\",JsonString_to_DataFrame,\n node_description=\"JSON String\")\n self.add_node(\"CsvFile\",\"DataFrame\",DataFrame_to_CsvFile,\n \"DataFrame\",CsvFile_to_DataFrame,\n node_description=\"CSV File\")\n self.add_node(\"MatFile\",\"AsciiDataTable\",AsciiTable_to_MatFile,\n \"AsciiDataTable\",MatFile_to_AsciiTable,\n node_description=\"Matlab File\")\n self.add_node(\"XmlFile\",\"XmlDataTable\",XmlDataTable_to_XmlFile,\n \"XmlDataTable\",XmlFile_to_XmlDataTable,\n node_description=\"XML DataTable Saved As a File\")\n self.add_node(\"HtmlFile\",\"HtmlString\",HtmlString_to_HtmlFile,\n \"HtmlString\",HtmlFile_to_HtmlString,\n node_description=\"HTML File\")\n self.add_edge(\"DataFrame\",\"HtmlFile\",DataFrame_to_HtmlFile)\n self.add_edge(\"JsonFile\",\"XmlDataTable\",JsonFile_to_XmlDataTable)\n self.add_external_node(\"XsltResultString\",\"XmlDataTable\",XmlBase_to_XsltResultString,\n external_node_description=\"XSLT Results String\")\n self.add_external_node(\"XsltResultFile\",\"XmlDataTable\",XmlBase_to_XsltResultFile,\n external_node_description=\"XSLT Results File\")\nclass ImageGraph(Graph):\n \"\"\"A transformation graph for images node types are image formats and external nodes are\n common image processing functions\n #!python\n defaults={\"graph_name\":\"Image Graph\",\n \"node_names\":['Image','png'],\n \"node_descriptions\":[\"PIL Image\",\"png\"],\n \"current_node\":'Image',\n \"state\":[1,0],\n \"data\":PIL.Image.open(os.path.join(TESTS_DIRECTORY,'test.png')),\n \"edge_2_to_1\":File_to_Image,\n \"edge_1_to_2\":lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"png\")}\n \"\"\"\n def __init__(self,**options):\n defaults={\"graph_name\":\"Image Graph\",\n \"node_names\":['Image','Png'],\n \"node_descriptions\":[\"PIL Image\",\"Png\"],\n \"current_node\":'Image',\n \"state\":[1,0],\n \"data\":PIL.Image.open(os.path.join(TESTS_DIRECTORY,'test.png')),\n \"edge_2_to_1\":File_to_Image,\n \"edge_1_to_2\":lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"png\")}\n self.options={}\n for key,value in defaults.items():\n self.options[key]=value\n for key,value in options.items():\n self.options[key]=value\n Graph.__init__(self,**self.options)\n self.add_node(\"Jpg\",\"Image\",lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"jpg\"),\n \"Image\",File_to_Image,node_description=\"Jpg File\")\n self.add_node(\"Tiff\",\"Image\",lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"tiff\"),\n \"Image\",File_to_Image,node_description=\"Tif File\")\n self.add_node(\"Gif\",\"Image\",lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"gif\"),\n \"Image\",File_to_Image,node_description=\"Gif File\")\n self.add_node(\"Bmp\",\"Image\",lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"bmp\"),\n \"Image\",File_to_Image,node_description=\"BMP File\")\n self.add_node(\"Base64\",\"Png\",PngFile_to_Base64,\n \"Png\",Base64_to_PngFile,node_description=\"Base 64 PNG\")\n self.add_node(\"EmbeddedHtml\",\"Base64\",Base64Png_to_EmbeddedHtmlString,\n \"Base64\",EmbeddedHtmlString_to_Base64Png,node_description=\"Embedded HTML of PNG\")\n self.add_node(\"Ndarray\",\"Png\",PngFile_to_Ndarray,\n \"Png\",Ndarray_to_PngFile,node_description=\"Numpy Array\")\n self.add_node(\"MatplotlibFigure\",\"Ndarray\",Ndarray_to_MatplotlibFigure,\n \"Png\",MatplotlibFigure_to_PngFile,node_description=\"MatplotlibFigure\")\n self.add_external_node(\"Thumbnail\",\"Image\",Image_to_ThumbnailFile,external_node_description=\"JPEG Thumbnail\")\n self.add_external_node(\"Matplotlib\",\"Ndarray\",Ndarray_to_Matplotlib,\n external_node_description=\"Matplotlib Plot\")\n\nclass MetadataGraph(Graph):\n \"\"\"Metadata Graph is a graph representing the content of key,value metadata\"\"\"\n def __init__(self,**options):\n \"\"\"Intializes the metadata graph class\"\"\"\n defaults={\"graph_name\":\"Metadata Graph\",\n \"node_names\":['Dictionary','JsonString'],\n \"node_descriptions\":[\"Python Dictionary\",\"Json string\"],\n \"current_node\":'Dictionary',\n \"state\":[1,0],\n \"data\":{\"a\":\"First\",\"b\":\"Second\"},\n \"edge_2_to_1\":JsonString_to_Dictionary,\n \"edge_1_to_2\":Dictionary_to_JsonString}\n self.options={}\n for key,value in defaults.items():\n self.options[key]=value\n for key,value in options.items():\n self.options[key]=value\n Graph.__init__(self,**self.options)\n self.add_node(\"JsonFile\",\"JsonString\",JsonString_to_JsonFile,\n \"JsonString\",JsonFile_to_JsonString,node_description=\"JSON File\")\n self.add_node(\"XmlString\",\"Dictionary\",Dictionary_to_XmlString,\n \"Dictionary\",XmlString_to_Dictionary,node_description=\"XML string\")\n self.add_node(\"HtmlMetaString\",\"Dictionary\",Dictionary_to_HtmlMetaString,\n \"Dictionary\",HtmlMetaString_to_Dictionary,node_description=\"HTML meta tags\")\n self.add_node(\"XmlTupleString\",\"Dictionary\",Dictionary_to_XmlTupleString,\n \"Dictionary\",XmlTupleString_to_Dictionary,node_description=\"Tuple Line\")\n self.add_node(\"PickleFile\",\"Dictionary\",Dictionary_to_PickleFile,\n \"Dictionary\",PickleFile_to_Dictionary,node_description=\"Pickled File\")\n self.add_node(\"ListList\",\"Dictionary\",Dictionary_to_ListList,\n \"Dictionary\",ListList_to_Dictionary,node_description=\"List of lists\")\n self.add_node(\"HeaderList\",\"Dictionary\",Dictionary_to_HeaderList,\n \"Dictionary\",HeaderList_to_Dictionary,node_description=\"Header List\")\n self.add_node(\"DataFrame\",\"Dictionary\",Dictionary_to_DataFrame,\n \"Dictionary\",DataFrame_to_Dictionary,node_description=\"Pandas DataFrame\")\n self.add_node(\"AsciiDataTable\",\"DataFrame\",DataFrame_to_AsciiDataTable,\n \"DataFrame\",AsciiDataTable_to_DataFrame,node_description=\"AsciiDataTable\")\n self.add_node(\"MatFile\",\"AsciiDataTable\",AsciiTable_to_MatFile,\n \"AsciiDataTable\",MatFile_to_AsciiDataTableKeyValue,node_description=\"Matlab\")\n self.add_node(\"ExcelFile\",\"DataFrame\",DataFrame_to_ExcelFile,\n \"DataFrame\",ExcelFile_to_DataFrame,node_description=\"excel\")\n self.add_node(\"HdfFile\",\"DataFrame\",DataFrame_to_HdfFile,\n \"DataFrame\",HdfFile_to_DataFrame,node_description=\"hdf file\")\n self.add_node(\"CsvFile\",\"DataFrame\",DataFrame_to_CsvFile,\n \"DataFrame\",CsvFile_to_DataFrame,node_description=\"CSV File\")\n self.add_node(\"HtmlFile\",\"DataFrame\",DataFrame_to_HtmlFile,\n \"DataFrame\",HtmlFile_to_DataFrame,node_description=\"HTML Table File\")\n self.add_node(\"HtmlTableString\",\"HtmlFile\",HtmlFile_to_HtmlString,\n \"HtmlFile\",HtmlString_to_HtmlFile,node_description=\"HTML Table String\")\nclass TwoPortParameterGraph(Graph):\n \"\"\"TwoPortParamterGraph is a content graph for two-port parameters,\n it transforms between S,T,Y,Z,ABCD and H parameters and matrix versions.\n #!python\n defaults={\"graph_name\":\"Two Port Parameter Graph\",\n \"node_names\":[\"SFrequencyList\",'SFrequencyMatrixList'],\n \"node_descriptions\":[\"S Parameters\",\"S Parameters in a Matrix\"],\n \"current_node\":'SFrequencyList',\n \"state\":[1,0],\n \"data\":[[1.0,.9,.436,.436,.9]],\n \"edge_2_to_1\":FrequencyMatrixList_to_FrequencyList,\n \"edge_1_to_2\":FrequencyList_to_FrequencyMatrixList,\n \"frequency_units\":\"GHz\",\n \"Z01\":50,\n \"Z02\":50 }\n\"\"\"\n def __init__(self,**options):\n\n defaults={\"graph_name\":\"Two Port Parameter Graph\",\n \"node_names\":[\"SFrequencyList\",'SFrequencyMatrixList'],\n \"node_descriptions\":[\"S Parameters\",\"S Parameters in a Matrix\"],\n \"current_node\":'SFrequencyList',\n \"state\":[1,0],\n \"data\":[[1.0,.9,.436,.436,.9]],\n \"edge_2_to_1\":FrequencyMatrixList_to_FrequencyList,\n \"edge_1_to_2\":FrequencyList_to_FrequencyMatrixList,\n \"frequency_units\":\"GHz\",\n \"Z01\":50,\n \"Z02\":50 }\n graph_options={}\n for key,value in defaults.items():\n graph_options[key]=value\n for key,value in options.items():\n graph_options[key]=value\n Graph.__init__(self,**graph_options)\n\n self.add_node(\"TFrequencyMatrixList\",\n \"SFrequencyMatrixList\",SFrequencyMatrixList_to_TFrequencyMatrixList,\n \"SFrequencyMatrixList\",TFrequencyMatrixList_to_SFrequencyMatrixList,\n \"T Parameters in a Matrix\")\n\n self.add_node(\"TFrequencyList\",\n \"TFrequencyMatrixList\",FrequencyMatrixList_to_FrequencyList,\n \"TFrequencyMatrixList\",FrequencyList_to_FrequencyMatrixList,\n \"T Parameters\")\n\n self.add_node(\"ZFrequencyList\",\n \"SFrequencyList\",SFrequencyList_to_ZFrequencyList,\n \"TFrequencyList\",ZFrequencyList_to_TFrequencyList,\n \"Z Parameters\")\n\n self.add_node(\"ZFrequencyMatrixList\",\n \"ZFrequencyList\",FrequencyList_to_FrequencyMatrixList,\n \"ZFrequencyList\",FrequencyMatrixList_to_FrequencyList,\n \"Z Parameters in a matrix\")\n\n self.add_node(\"ABCDFrequencyList\",\n \"ZFrequencyList\",ZFrequencyList_to_ABCDFrequencyList,\n \"ZFrequencyList\",ABCDFrequencyList_to_ZFrequencyList,\n \"ABCD Parameters\")\n\n self.add_node(\"ABCDFrequencyMatrixList\",\n \"ABCDFrequencyList\",FrequencyList_to_FrequencyMatrixList,\n \"ABCDFrequencyList\",FrequencyMatrixList_to_FrequencyList,\n \"ABCD Parameters in a matrix\")\n\n self.add_node(\"HFrequencyList\",\n \"ABCDFrequencyList\",ABCDFrequencyList_to_HFrequencyList,\n \"ZFrequencyList\",HFrequencyList_to_ZFrequencyList,\n \"h Parameters\")\n\n self.add_node(\"HFrequencyMatrixList\",\n \"HFrequencyList\",FrequencyList_to_FrequencyMatrixList,\n \"HFrequencyList\",FrequencyMatrixList_to_FrequencyList,\n \"H Parameters in a matrix\")\n self.add_node(\"YFrequencyList\",\n \"ABCDFrequencyList\",ABCDFrequencyList_to_YFrequencyList,\n \"HFrequencyList\",YFrequencyList_to_HFrequencyList,\n \"Y Parameters\")\n\n self.add_node(\"YFrequencyMatrixList\",\n \"YFrequencyList\",FrequencyList_to_FrequencyMatrixList,\n \"YFrequencyList\",FrequencyMatrixList_to_FrequencyList,\n \"Y Parameters in a matrix\")\n\n self.add_edge(begin_node=\"ZFrequencyMatrixList\",\n end_node=\"YFrequencyMatrixList\",\n edge_function=ZFrequencyMatrixList_to_YFrequencyMatrixList)\n\n self.add_edge(begin_node=\"SFrequencyMatrixList\",\n end_node=\"ZFrequencyMatrixList\",\n edge_function=SFrequencyMatrixList_to_ZFrequencyMatrixList)\n\n self.add_edge(begin_node=\"ZFrequencyMatrixList\",\n end_node=\"TFrequencyMatrixList\",\n edge_function=ZFrequencyMatrixList_to_TFrequencyMatrixList)\n\n self.add_edge(begin_node=\"ABCDFrequencyList\",\n end_node=\"SFrequencyList\",\n edge_function=ABCDFrequencyList_to_SFrequencyList)\nclass DataTableGraph(Graph):\n \"\"\" Class that transforms a row modelled header and metadata to several different data types\n #!python\n defaults={\"graph_name\":\"Data Table Graph\",\n \"node_names\":['DataFrameDictionary','AsciiDataTable'],\n \"node_descriptions\":[\"Pandas Data Frame Dictionary\",\"AsciiDataTable\"],\n \"current_node\":'DataFrameDictionary',\n \"state\":[1,0],\n \"data\":AsciiDataTable_to_DataFrameDictionary(TwoPortRawModel(os.path.join(TESTS_DIRECTORY,'TestFileTwoPortRaw.txt'))),\n \"edge_2_to_1\":AsciiDataTable_to_DataFrameDictionary,\n \"edge_1_to_2\":DataFrameDictionary_to_AsciiDataTable\n }\n \"\"\"\n def __init__(self,**options):\n\n defaults={\"graph_name\":\"Data Table Graph\",\n \"node_names\":['DataFrameDictionary','AsciiDataTable'],\n \"node_descriptions\":[\"Pandas Data Frame Dictionary\",\"AsciiDataTable\"],\n \"current_node\":'DataFrameDictionary',\n \"state\":[1,0],\n \"data\":AsciiDataTable_to_DataFrameDictionary(TwoPortRawModel(os.path.join(TESTS_DIRECTORY,'TestFileTwoPortRaw.txt'))),\n \"edge_2_to_1\":AsciiDataTable_to_DataFrameDictionary,\n \"edge_1_to_2\":DataFrameDictionary_to_AsciiDataTable\n }\n graph_options={}\n for key,value in defaults.items():\n graph_options[key]=value\n for key,value in options.items():\n graph_options[key]=value\n Graph.__init__(self, **graph_options)\n\n self.add_node(\"ExcelFile\", \"DataFrameDictionary\", DataFrameDictionary_to_ExcelFile,\n \"DataFrameDictionary\", ExcelFile_to_DataFrameDictionary,\n node_description=\"Excel Workbook\")\n self.add_node(\"HdfFile\", \"DataFrameDictionary\", DataFrameDictionary_to_HdfFile,\n \"DataFrameDictionary\", HdfFile_to_DataFrameDictionary, node_description=\"HD5 File\")\n self.add_node(\"CsvFile\", \"AsciiDataTable\", AsciiDataTable_to_CsvFile,\n \"AsciiDataTable\", File_to_AsciiDataTable, node_description=\"CSV File\")\n self.add_node(\"HpFile\", \"AsciiDataTable\", AsciiDataTable_to_HpFile,\n \"AsciiDataTable\", File_to_AsciiDataTable, node_description=\"hp format File\")\n self.add_external_node(external_node_name=\"XMLDataTable\", jump_into_node_begin=\"AsciiDataTable\",\n jump_into_node_function=AsciiDataTable_to_XmlDataTable,\n external_node_description=\"XMLDataTable\")\n#-----------------------------------------------------------------------------\n# Module Scripts\n#TODO: Add test_Graph script currently lives in jupyter-notebooks\n\n#-----------------------------------------------------------------------------\n# Module Runner\nif __name__ == '__main__':\n pass"},"implementation":{"kind":"string","value":" def check_closed_path(self):\n \"\"\"Checks that data is not changed for the first closed path found. Returns True if data==data after\n moving around the closed path, False otherwise. Starting point is current_node \"\"\"\n temp_data = self.data\n path = self.get_path(self.current_node, self.current_node)\n if self.is_path_valid(path):\n pass\n else:\n print(\"Path is not valid, graph definition is broken\")\n raise\n out = temp_data == self.data\n out_list = [self.current_node, path, out]\n print((\"The assertion that the data remains unchanged,\\n\"\n \"for node {0} following path {1} is {2}\".format(*out_list)))\n return out"},"start_line":{"kind":"number","value":615,"string":"615"},"end_line":{"kind":"number","value":629,"string":"629"},"file_content":{"kind":"string","value":"#-----------------------------------------------------------------------------\n# Name: GraphModels\n# Purpose: To store graphs used in network translations\n# Author: Aric Sanders\n# Created: 4/6/2016\n# License: MIT License\n#-----------------------------------------------------------------------------\n\"\"\"\nGraph Models stores sub classes of graphs that define data translations. All edges\nor the functions that define translations from one format to another\nare found in <a href=\"./Translations.m.html\">`pyMez.Code.DataHandlers.Translations`</a>.\nCurrently, the module networkx is used to display the graph.\n\nExamples\n--------\n #!python\n >>from pyMez import *\n >>image_graph=ImageGraph()\n >>image_graph.set_state('png','my_png.png')\n >>image_graph.move_to_node('EmbeddedHtml')\n >>output=image_graph.data\n >>print output\n\n\n<h3><a href=\"../../../Examples/Html/GraphModels_Example.html\">GraphModels Example</a></h3>\n\nRequirements\n------------\n+ [sys](https://docs.python.org/2/library/sys.html)\n+ [os](https://docs.python.org/2/library/os.html?highlight=os#module-os)\n+ [networkx](http://networkx.github.io/)\n+ [numpy](http://www.numpy.org/)\n+ [pyMez](https://github.com/aricsanders/pyMez)\n\nHelp\n---------------\n<a href=\"./index.html\">`pyMez.Code.DataHandlers`</a>\n<div>\n<a href=\"../../../pyMez_Documentation.html\">Documentation Home</a> |\n<a href=\"../../index.html\">API Documentation Home</a> |\n<a href=\"../../../Examples/html/Examples_Home.html\">Examples Home</a> |\n<a href=\"../../../Reference_Index.html\">Index</a>\n</div>\n \"\"\"\n\n#-----------------------------------------------------------------------------\n# Standard Imports\nimport re\nimport datetime\nimport sys\nimport os\n\n#-----------------------------------------------------------------------------\n# Third Party Imports\nsys.path.append(os.path.join(os.path.dirname( __file__ ), '..','..'))\ntry:\n from Code.Utils.Alias import *\n METHOD_ALIASES=1\nexcept:\n print(\"The module pyMez.Code.Utils.Alias was not found\")\n METHOD_ALIASES=0\n pass\ntry:\n from Code.DataHandlers.GeneralModels import *\nexcept:\n print(\"The module pyMez.Code.DataHandlers.GeneralModels was not found,\"\n \"please put it on the python path\")\n raise ImportError\ntry:\n from Code.DataHandlers.TouchstoneModels import *\nexcept:\n print(\"The module pyMez.Code.DataHandlers.TouchstoneModels was not found,\"\n \"please put it on the python path\")\n raise ImportError\ntry:\n from Code.DataHandlers.Translations import *\nexcept:\n print(\"The module pyMez.Code.DataHandlers.Translations was not found or had an error,\"\n \"please put it on the python path or resolve the error\")\n raise ImportError\ntry:\n import numpy as np\nexcept:\n print(\"The module numpy was not found,\"\n \"please put it on the python path\")\n raise ImportError\ntry:\n import networkx\nexcept:\n print(\"The module networkx was not found,\"\n \"please put it on the python path\")\n raise ImportError\n\n#-----------------------------------------------------------------------------\n# Module Constants\n\n#-----------------------------------------------------------------------------\n# Module Functions\n\n# as an example these functions are left.\n#todo: Change the names\ndef edge_1_to_2(in_string):\n \"A Test function for an edge for a Graph\"\n return in_string.splitlines()\n\ndef edge_2_to_1(string_list):\n \"\"\"A test function for an edge in a Graph\"\"\"\n return string_list_collapse(string_list)\n\ndef visit_all_nodes(graph):\n \"\"\"Visit all nodes visits each node on a graph\"\"\"\n nodes=graph.node_names\n for node in nodes:\n graph.move_to_node(node)\n\ndef visit_and_print_all_nodes(graph):\n \"\"\"Visits all the nodes in graph and prints graph.data after each move\"\"\"\n nodes=graph.node_names\n for node in nodes:\n graph.move_to_node(node)\n print((graph.data))\n\n\ndef to_node_name(node_data):\n \"\"\"Creates a node name given an input object, does a bit of silly type selecting and name rearranging. This matches for 75%\n of the cases. There are a lot of user defined nodes without a clear path to generate a name. For instance the DataTableGraph\n node HpFile, does not save with a .hp extension so it would be auto named TxtFile if was only selected by the path name.\n If it is auto selected it returns StringList because it is of the format [\"file_path\",\"schema_path\"] \"\"\"\n\n # we retrieve the text version of the class name\n class_name = node_data.__class__.__name__\n node_name = class_name\n # now for dict and list types we want to inspect the first Element to see what it is\n if re.match('list', class_name):\n node_name = \"List\"\n try:\n element_class_name = node_data[0].__class__.__name__\n node_name = element_class_name + node_name\n except:\n pass\n elif re.match('dict', class_name):\n node_name = \"Dictionary\"\n try:\n element_class_name = list(node_data.values())[0].__class__.__name__\n node_name = element_class_name + node_name\n except:\n pass\n elif re.match('str', class_name):\n node_name = \"String\"\n # Now we have to check if it is an existing file name\n if os.path.isfile(node_data):\n node_name = \"File\"\n extension = \"\"\n try:\n if re.search(\"\\.\", node_data):\n extension = node_data.split(\".\")[-1]\n node_name = extension.title() + node_name\n except:\n pass\n elif fnmatch.fnmatch(node_data, \"*.*\"):\n node_name = \"File\"\n try:\n if re.search(\"\\.\", node_data):\n extension = node_data.split(\".\")[-1]\n node_name = extension.title() + node_name\n except:\n pass\n node_name = node_name.replace(\"str\", \"String\").replace(\"dict\", \"Dictionary\")\n return (node_name)\n\n\ndef TableGraph_to_Links(table_graph, **options):\n \"\"\"Converts a table graph to a set of download links with embedded data in them\"\"\"\n defaults = {\"base_name\": None,\n \"nodes\": ['XmlFile', 'CsvFile', 'ExcelFile', 'OdsFile', 'MatFile', 'HtmlFile', 'JsonFile'],\n \"extensions\": ['xml', 'csv', 'xlsx', 'ods', 'mat', 'html', 'json'],\n \"mime_types\": ['application/xml', 'text/plain',\n 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n 'application/vnd.oasis.opendocument.spreadsheet',\n 'application/x-matlab-data', 'text/html', 'application/json']}\n conversion_options = {}\n for key, value in defaults.items():\n conversion_options[key] = value\n for key, value in options.items():\n conversion_options[key] = value\n if conversion_options[\"base_name\"] is None:\n base_name = 'test.txt'\n else:\n base_name = conversion_options[\"base_name\"]\n\n nodes = conversion_options[\"nodes\"]\n extensions = conversion_options[\"extensions\"]\n mime_types = conversion_options[\"mime_types\"]\n\n out_links = \"\"\n for node_index, node in enumerate(nodes):\n table_graph.move_to_node(node)\n file_path = table_graph.data\n in_file = open(file_path, 'rb')\n content_string = in_file.read()\n link = String_to_DownloadLink(content_string,\n suggested_name=change_extension(base_name, extensions[node_index]),\n mime_type=mime_types[node_index],\n text=extensions[node_index])\n if node_index == len(nodes) - 1:\n out_links = out_links + link\n else:\n out_links = out_links + link + \" | \"\n return out_links\n\n\ndef remove_circular_paths(path):\n \"\"\"Removes pieces of the path that just end on the same node\"\"\"\n # Todo: Track the error that leaves out a needed path sometimes\n # See http://localhost:8888/notebooks/Two_Port_Matrix_Parameters_Debug_20170105_001.ipynb\n\n edge_pattern=re.compile(\"edge_(?P<begin_node>\\w+)_(?P<end_node>\\w+)_(?P<iterator>\\w+)\")\n past_locations=[]\n\n for index,edge in enumerate(path):\n match=re.match(edge_pattern,edge)\n begin_node=match.groupdict()[\"begin_node\"]\n end_node=match.groupdict()[\"end_node\"]\n past_locations.append(begin_node)\n #print(\"{0} is {1}\".format(\"past_locations\",past_locations))\n new_path=[]\n node_index=0\n between_list=[False for item in past_locations]\n while(node_index<len(past_locations)):\n node=past_locations[node_index]\n old_path=new_path\n new_path=[]\n # if you visit a location more than one\n number_of_visits=past_locations.count(node)\n if number_of_visits>1:\n #print(\"{0} is {1}\".format(\"node\",node))\n #print(\"{0} is {1}\".format(\"past_locations\",past_locations))\n # Now find all the visits to that location\n equality_list=[x==node for x in past_locations]\n print((\"{0} is {1}\".format(\"equality_list\",equality_list)))\n # You are intially not between visits\n between=False\n\n # every time you cross that node you flip between, as long as there are\n visit_number=0\n for index,equality in enumerate(equality_list):\n if equality:\n # add one to the visit number\n visit_number+=1\n # Flip the between truth value if it is the first or last\n # visits only\n if visit_number==1 or visit_number==number_of_visits:\n between=not between\n between_list[index]=between or between_list[index]\n else:\n between_list[index]=between or between_list[index]\n else:\n between_list[index]=between or between_list[index]\n #print(\"{0} is {1}\".format(\"between_list\",between_list))\n for index,item in enumerate(between_list):\n if not item:\n new_path.append(path[index])\n node_index+=1\n if new_path in [[]]:\n new_path=path\n return new_path\n#-----------------------------------------------------------------------------\n# Module Classes\n\n# getting around to adding a breadth first graph solver to Graph class\n# modify the find_path method\nclass Graph(object):\n \"\"\"The Graph class creates a content graph that has as nodes different formats. As\n a format is added via graph.add_node() by specifying a node name and a function from an\n existing node into the new one, and one exiting the node. Once a series of nodes exists\n to enter the graph at a node use graph.set_state() the current data representing the\n state is in the attribute graph.data. To move among the formats use graph.move_to_node('NodeName')\n need to recode the find_path method using a shortest path alogrithm like\n [Dijkstra](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm).\n \"\"\"\n\n def __init__(self, **options):\n \"\"\"Initializes the graph. The first 2 nodes and two edges forming a bijection between them are required\"\"\"\n defaults = {\"graph_name\": \"Graph\",\n \"node_names\": ['n1', 'n2'],\n \"node_descriptions\": [\"A plain string\",\n \"A list of strings with no \\\\n, created with string.splitlines()\"],\n \"current_node\": 'n1',\n \"state\": [1, 0],\n \"data\": \"This is a test string\\n it has to have multiple lines \\n and many characters 34%6\\n^\",\n \"edge_2_to_1\": edge_2_to_1,\n \"edge_1_to_2\": edge_1_to_2\n }\n self.options = {}\n for key, value in defaults.items():\n self.options[key] = value\n for key, value in options.items():\n self.options[key] = value\n self.elements = ['graph_name', 'node_names', 'node_descriptions', 'current_node', 'state', 'data']\n for element in self.elements:\n self.__dict__[element] = self.options[element]\n self.edges = []\n self.edge_matrices = []\n self.state_matrix = np.matrix(self.state).T\n # Add the first 2 edges, required to intialize the graph properly\n self.display_graph = networkx.DiGraph()\n\n self.add_edge(self.node_names[0], self.node_names[1], self.options[\"edge_1_to_2\"])\n self.add_edge(self.node_names[1], self.node_names[0], self.options[\"edge_2_to_1\"])\n self.jumps = []\n self.external_node_names = []\n self.external_node_descriptions = []\n self.display_layout = networkx.spring_layout(self.display_graph)\n\n def get_description_dictionary(self):\n \"returns a dictionary of the form {NodeName:Node Description for all of the current nodes\"\n dictionary = {node_name: self.node_descriptions[index] for index, node_name in enumerate(self.node_names)}\n return dictionary\n\n def set_state(self, node_name, node_data):\n \"\"\"Sets the graph state to be the state specified by node_name, and node_data\"\"\"\n try:\n current_node_state_position = self.node_names.index(node_name)\n self.current_node = node_name\n self.data = node_data\n self.state = [0 for i in range(len(self.node_names))]\n self.state[current_node_state_position] = 1\n self.state_matrix = np.matrix(self.state).T\n except:\n print((\"Could not set the state of graph: {0}\".format(self.graph_name)))\n raise\n\n def add_edge(self, begin_node=None, end_node=None, edge_function=None):\n \"\"\"Adds an edge mapping one node to another, required input is begin_node (it's name)\n end_node, and the edge function\"\"\"\n # check to see if edge is defined if it is increment a number\n edge_match = re.compile(\"edge_{0}_{1}\".format(begin_node, end_node))\n keys = list(self.__dict__.keys())\n # print keys\n iterator = 0\n for key in keys:\n if re.match(edge_match, key):\n iterator += 1\n edge_name = \"edge_{0}_{1}_{2:0>3d}\".format(begin_node, end_node, iterator)\n self.__dict__[edge_name] = edge_function\n self.edges.append(edge_name)\n edge_matrix = np.zeros((len(self.state), len(self.state)))\n begin_position = self.node_names.index(begin_node)\n end_position = self.node_names.index(end_node)\n edge_matrix[end_position][begin_position] = 1\n edge_matrix = np.matrix(edge_matrix)\n self.edge_matrices.append(edge_matrix)\n self.display_graph.add_edge(begin_node, end_node)\n self.display_layout = networkx.spring_layout(self.display_graph)\n\n def add_jump(self, begin_node=None, end_node=None, jump_function=None):\n \"\"\"Adds a jump mapping one internal node to an external node, required input is begin_node (it's name)\n end_node, and the edge function\"\"\"\n # check to see if edge is defined if it is increment a number\n jump_match = re.compile(\"jump_{0}_{1}\".format(begin_node, end_node))\n keys = list(self.__dict__.keys())\n # print keys\n iterator = 0\n for key in keys:\n if re.match(jump_match, key):\n iterator += 1\n jump_name = \"jump_{0}_{1}_{2:0>3d}\".format(begin_node, end_node, iterator)\n self.__dict__[jump_name] = jump_function\n self.jumps.append(jump_name)\n self.display_graph.add_edge(begin_node, end_node)\n self.display_layout = networkx.spring_layout(self.display_graph)\n\n def move_to(self, path, **options):\n \"\"\"Changes the state of the graph by moving along the path specified\"\"\"\n defaults = {\"debug\": False, \"verbose\": False}\n move_options = {}\n for key, value in defaults.items():\n move_options[key] = value\n for key, value in options.items():\n move_options[key] = value\n\n if move_options[\"debug\"]:\n print(path)\n for index, edge in enumerate(path):\n # print edge\n edge_pattern = 'edge_(?P<begin_node>\\w+)_(?P<end_node>\\w+)_(?P<iterator>\\w+)'\n match = re.match(edge_pattern, edge)\n begin_node = match.groupdict()['begin_node']\n end_node = match.groupdict()['end_node']\n if move_options[\"verbose\"]:\n print((\"moving {0} -> {1}\".format(begin_node, end_node)))\n # print self.data\n self.data = self.__dict__[edge](self.data)\n # print self.data\n self.current_node = match.groupdict()['end_node']\n self.state = [0 for i in range(len(self.node_names))]\n position = self.node_names.index(self.current_node)\n self.state[position] = 1\n self.state_matrix = np.matrix(self.state).T\n # print self.state\n # print self.current_node\n\n def virtual_move_to(self, path):\n \"\"\"virtual_move_to simulates moving but does not change the state of the graph\"\"\"\n # print path\n temp_state = self.state\n temp_data = self.data\n temp_current_node = self.current_node\n temp_node_names = self.node_names\n for index, edge in enumerate(path):\n # print edge\n edge_pattern = 'edge_(?P<begin_node>\\w+)_(?P<end_node>\\w+)_(?P<iterator>\\w+)'\n match = re.match(edge_pattern, edge)\n begin_node = match.groupdict()['begin_node']\n end_node = match.groupdict()['end_node']\n # print(\"moving {0} -> {1}\".format(begin_node,end_node))\n # print self.data\n temp_data = self.__dict__[edge](temp_data)\n # print self.data\n temp_current_node = match.groupdict()['end_node']\n temp_state = [0 for i in range(len(temp_node_names))]\n position = temp_node_names.index(temp_current_node)\n temp_state[position] = 1\n # print temp_state\n # print self.state\n # print self.current_node\n\n def __str__(self):\n return str(self.data)\n\n def add_node(self, node_name, edge_into_node_begin, edge_into_node_function, edge_out_node_end,\n edge_out_node_function, node_description=None):\n \"\"\"Adds a node to the graph. Required input is node_name (a string with no spaces),\n a reference to an entering node,the function mapping the entering node to the new node,\n a reference to an exiting node and the function mapping the\n new node to the exiting node.\"\"\"\n # first check if node into and out of node is good\n self.node_names.append(node_name)\n self.state.append(0)\n self.state_matrix = np.matrix(self.state).T\n for index, matrix in enumerate(self.edge_matrices):\n pad_row = np.zeros((1, len(matrix)))\n new_matrix = np.concatenate((matrix, pad_row), axis=0)\n pad_column = np.zeros((1, len(self.node_names)))\n new_matrix = np.concatenate((new_matrix, pad_column.T), axis=1)\n # print(\"New matrix is :\\n{0}\".format(new_matrix))\n self.edge_matrices[index] = new_matrix\n self.add_edge(begin_node=node_name, end_node=edge_out_node_end, edge_function=edge_out_node_function)\n self.add_edge(begin_node=edge_into_node_begin, end_node=node_name, edge_function=edge_into_node_function)\n if node_description:\n self.node_descriptions.append(node_description)\n self.display_graph.add_node(node_name)\n self.display_graph.add_edge(node_name, edge_out_node_end)\n self.display_graph.add_edge(edge_into_node_begin, node_name)\n self.display_layout = networkx.spring_layout(self.display_graph)\n\n def add_external_node(self, external_node_name, jump_into_node_begin,\n jump_into_node_function, external_node_description=None):\n \"\"\"Adds an external node to the graph. Required input is node_name (a string with no spaces),\n a reference to an entering node,the function mapping the entering node to the new external node\"\"\"\n # first check if node into and out of node is good\n self.external_node_names.append(external_node_name)\n self.add_jump(begin_node=jump_into_node_begin, end_node=external_node_name,\n jump_function=jump_into_node_function)\n if external_node_description:\n self.external_node_descriptions.append(external_node_description)\n self.display_graph.add_node(external_node_name)\n self.display_graph.add_edge(jump_into_node_begin, external_node_name)\n self.display_layout = networkx.spring_layout(self.display_graph)\n\n def jump_to_external_node(self, external_node_name, **options):\n \"\"\"Returns the result of the jump, the graph is left in the node that is the begining of the jump\"\"\"\n end_node = external_node_name\n jump_pattern = 'jump_(?P<begin_node>\\w+)_{0}_(?P<iterator>\\w+)'.format(end_node)\n for jump in self.jumps[:]:\n jump_match = re.match(jump_pattern, jump, re.IGNORECASE)\n if jump_match:\n jump_to_use = jump\n begin_node = jump_match.groupdict()[\"begin_node\"]\n\n self.move_to_node(begin_node)\n return self.__dict__[jump_to_use](self.data, **options)\n\n def path_length(self, path, num_repeats=10):\n \"\"\"Determines the length of a given path, currently the metric is based on the time to move to.\"\"\"\n begin_time = datetime.datetime.now()\n # num_repeats=100\n for i in range(num_repeats):\n self.virtual_move_to(path)\n end_time = datetime.datetime.now()\n delta_t = end_time - begin_time\n path_length = delta_t.total_seconds() / float(num_repeats)\n if path_length == 0.0:\n print(\"Warning the path length is less than 1 microsecond,\"\n \"make sure num_repeats is high enough to measure it.\")\n return path_length\n\n def is_path_valid(self, path):\n \"\"\"Returns True if the path is valid from the current node position or False otherwise\"\"\"\n null_state = [0 for i in range(len(self.node_names))]\n null_state_matrix = np.matrix(null_state).T\n new_state = np.matrix(self.state).T\n for index, edge in enumerate(path):\n # print index\n # print edge\n edge_position = self.edges.index(edge)\n move_matrix = self.edge_matrices[edge_position]\n # print move_matrix\n new_state = move_matrix * new_state\n if new_state.any() == null_state_matrix.any():\n # print new_state\n # print null_state_matrix\n return False\n return True\n\n def get_entering_nodes(self, node):\n \"\"\"Returns all nodes that have an edge that enter the specificed node\"\"\"\n enter_edge_pattern = re.compile('edge_(?P<begin_node>\\w+)_{0}_(?P<iterator>\\w+)'.format(node))\n enter_nodes = []\n for index, edge in enumerate(self.edges):\n enter_match = re.match(enter_edge_pattern, edge)\n if enter_match:\n enter_node = enter_match.groupdict()['begin_node']\n enter_nodes.append(enter_node)\n return enter_nodes\n\n def get_entering_edges(self, node):\n \"\"\"Returns all edges that enter the specificed node\"\"\"\n enter_edge_pattern = re.compile('edge_(?P<begin_node>\\w+)_{0}_(?P<iterator>\\w+)'.format(node))\n enter_edges = []\n for index, edge in enumerate(self.edges):\n if re.match(enter_edge_pattern, edge):\n enter_edges.append(edge)\n return enter_edges\n\n def get_exiting_edges(self, node):\n \"\"\"Returns all edges that exit the specificed node\"\"\"\n exit_edge_pattern = re.compile('edge_{0}_(?P<end_node>\\w+)_(?P<iterator>\\w+)'.format(node))\n exit_edges = []\n for index, edge in enumerate(self.edges):\n if re.match(exit_edge_pattern, edge):\n exit_edges.append(edge)\n return exit_edges\n\n def get_exiting_nodes(self, node):\n \"\"\"Returns all nodes that have an edge leaving the specificed node\"\"\"\n exit_edge_pattern = re.compile('edge_{0}_(?P<end_node>\\w+)_(?P<iterator>\\w+)'.format(node))\n exit_nodes = []\n for index, edge in enumerate(self.edges):\n exit_match = re.match(exit_edge_pattern, edge)\n if exit_match:\n exit_node = exit_match.groupdict()['end_node']\n exit_nodes.append(exit_node)\n return exit_nodes\n\n def get_path(self, first_node, last_node, **options):\n \"\"\"Returns the first path found between first node and last node, uses a breadth first search algorithm\"\"\"\n defaults = {\"debug\": False, \"method\": \"BreathFirst\"}\n self.get_path_options = {}\n for key, value in defaults.items():\n self.get_path_options[key] = value\n for key, value in options.items():\n self.get_path_options[key] = value\n unvisited_nodes = self.node_names[:]\n unvisited_nodes.remove(first_node)\n visited_nodes = [first_node]\n node_history = []\n edge_history = []\n path_queue = []\n possible_paths = []\n queue = []\n current_edge = []\n queue.append(first_node)\n path = {first_node: []}\n while queue:\n # first remove the\n current_node = queue.pop(0)\n if path_queue != []:\n current_edge = path_queue.pop(0)\n edge_history.append(current_edge)\n node_history.append(current_node)\n if self.get_path_options[\"debug\"]:\n print((\"current_node is {0}\".format(current_node)))\n print((\"current_edge is {0}\".format(current_edge)))\n # if this node is the destination exit returning the path\n if current_node == last_node:\n if self.get_path_options[\"debug\"]:\n print((\"Node path was found to be {0}\".format(node_path)))\n print((\"path was found to be {0}\".format(edge_path)))\n print((\"{0} is {1}\".format(\"path\", path)))\n return path[last_node][::-1]\n\n adjacent_nodes = self.get_exiting_nodes(current_node)\n adjacent_paths = self.get_exiting_edges(current_node)\n if self.get_path_options[\"debug\"]:\n print((\"{0} are {1}\".format(\"adjacent_nodes\", adjacent_nodes)))\n print((\"{0} are {1}\".format(\"adjacent_paths\", adjacent_paths)))\n current_history = edge_history\n for node_index, node in enumerate(adjacent_nodes):\n if node not in visited_nodes:\n queue.append(node)\n path_queue.append(adjacent_paths[node_index])\n visited_nodes.append(node)\n path[node] = [adjacent_paths[node_index]] + path[current_node]\n path[node]\n # possible_paths.append(current_path.append(node))\n if self.get_path_options[\"debug\"]:\n print((\"{0} is {1}\".format(\"path_queue\", path_queue)))\n\n def move_to_node(self, node):\n \"\"\"Moves from current_node to the specified node\"\"\"\n path = self.get_path(self.current_node, node)\n self.move_to(path)\n\n def check_closed_path(self):\n \"\"\"Checks that data is not changed for the first closed path found. Returns True if data==data after\n moving around the closed path, False otherwise. Starting point is current_node \"\"\"\n temp_data = self.data\n path = self.get_path(self.current_node, self.current_node)\n if self.is_path_valid(path):\n pass\n else:\n print(\"Path is not valid, graph definition is broken\")\n raise\n out = temp_data == self.data\n out_list = [self.current_node, path, out]\n print((\"The assertion that the data remains unchanged,\\n\"\n \"for node {0} following path {1} is {2}\".format(*out_list)))\n return out\n\n def is_graph_isomorphic(self):\n \"\"\"Returns True if all nodes have closed paths that preserve the data, False otherwise\"\"\"\n out = True\n for node in self.node_names:\n self.move_to_node(node)\n if not self.check_closed_path:\n out = False\n return out\n\n def show(self, **options):\n \"\"\"Shows the graph using matplotlib and networkx\"\"\"\n # Should be seperated to allow for fixed presentation?\n defaults = {\"descriptions\": False, \"edge_descriptions\": False, \"save_plot\": False,\n \"path\": None, \"active_node\": True, \"directory\": None,\n \"specific_descriptor\": self.graph_name.replace(\" \", \"_\"),\n \"general_descriptor\": \"plot\", \"file_name\": None,\n \"arrows\": True, \"node_size\": 1000, \"font_size\": 10, \"fix_layout\": True}\n show_options = {}\n for key, value in defaults.items():\n show_options[key] = value\n for key, value in options.items():\n show_options[key] = value\n if show_options[\"directory\"] is None:\n show_options[\"directory\"] = os.getcwd()\n if show_options[\"active_node\"]:\n node_colors = []\n for node in self.display_graph.nodes():\n if node == self.current_node:\n node_colors.append('b')\n else:\n if node in self.node_names:\n node_colors.append('r')\n elif node in self.external_node_names:\n node_colors.append('g')\n else:\n node_colors = ['r' for node in self.node_names] + ['g' for node in self.node_names]\n # print(\"{0} is {1}\".format('node_colors',node_colors))\n if show_options[\"descriptions\"]:\n node_labels = {node: self.node_descriptions[index] for index,\n node in enumerate(self.node_names)}\n if self.external_node_names:\n for index, node in enumerate(self.external_node_names):\n node_labels[node] = self.external_node_descriptions[index]\n networkx.draw_networkx(self.display_graph, arrows=show_options[\"arrows\"],\n labels=node_labels, node_color=node_colors,\n node_size=show_options[\"node_size\"], font_size=show_options[\"font_size\"],\n pos=self.display_layout)\n # print(\"{0} is {1}\".format('node_labels',node_labels))\n else:\n networkx.draw_networkx(self.display_graph, arrows=show_options[\"arrows\"], node_color=node_colors,\n node_size=show_options[\"node_size\"], font_size=show_options[\"font_size\"],\n pos=self.display_layout)\n plt.axis('off')\n plt.suptitle(self.options[\"graph_name\"])\n if show_options[\"file_name\"] is None:\n file_name = auto_name(specific_descriptor=show_options[\"specific_descriptor\"],\n general_descriptor=show_options[\"general_descriptor\"],\n directory=show_options[\"directory\"], extension='png', padding=3)\n else:\n file_name = show_options[\"file_name\"]\n if show_options[\"save_plot\"]:\n # print file_name\n if show_options[\"path\"]:\n plt.savefig(show_options[\"path\"])\n else:\n plt.savefig(os.path.join(show_options[\"directory\"], file_name))\n else:\n plt.show()\n fig = plt.gcf()\n return fig\n\n\n\nclass StringGraph(Graph):\n \"\"\"String Graph is a graph relating different string forms\"\"\"\n def __init__(self,**options):\n \"\"\"Intializes the StringGraph Class by defining nodes and edges\"\"\"\n defaults={\"graph_name\":\"StringGraph\",\n \"node_names\":['String','StringList'],\n \"node_descriptions\":[\"A plain string\",\n \"A list of strings with no \\\\n, created with string.splitlines()\"],\n \"current_node\":'String',\n \"state\":[1,0],\n \"data\":\"This is a test string\\n it has to have multiple lines \\n and many characters 34%6\\n^\",\n \"edge_2_to_1\":edge_2_to_1,\n \"edge_1_to_2\":edge_1_to_2\n }\n self.options={}\n for key,value in defaults.items():\n self.options[key]=value\n for key,value in options.items():\n self.options[key]=value\n Graph.__init__(self,**self.options)\n self.add_node(\"File\",\"String\",String_to_File,\"String\",File_to_String,node_description=\"Plain File\")\n self.add_node(\"CStringIo\",\"String\",String_to_CStringIo,\"String\",CStringIo_to_String,node_description=\"C File Like Object\")\n self.add_node(\"StringIo\",\"String\",String_to_StringIo,\"String\",StringIo_to_String,node_description=\"File Like Object\")\n self.add_edge(begin_node=\"StringList\",end_node=\"File\",edge_function=StringList_to_File)\n\n\n# Changed from ColumnModeledGraph to TableGraph 12/14/2016 by AWS\nclass TableGraph(Graph):\n \"\"\"Class that transforms column modeled data (table) from one format to another, use set_state to initialize to\n your data.\n #!python\n defaults={\"graph_name\":\"Table Graph\",\n \"node_names\":['DataFrame','AsciiDataTable'],\n \"node_descriptions\":[\"Pandas Data Frame\",\"AsciiDataTable\"],\n \"current_node\":'DataFrame',\n \"state\":[1,0],\n \"data\":pandas.DataFrame([[1,2,3],[3,4,5]],columns=[\"a\",\"b\",\"c\"]),\n \"edge_2_to_1\":AsciiDataTable_to_DataFrame,\n \"edge_1_to_2\":DataFrame_to_AsciiDataTable}\n \"\"\"\n def __init__(self,**options):\n defaults={\"graph_name\":\"Table Graph\",\n \"node_names\":['DataFrame','AsciiDataTable'],\n \"node_descriptions\":[\"Pandas Data Frame\",\"AsciiDataTable\"],\n \"current_node\":'DataFrame',\n \"state\":[1,0],\n \"data\":pandas.DataFrame([[1,2,3],[3,4,5]],columns=[\"a\",\"b\",\"c\"]),\n \"edge_2_to_1\":AsciiDataTable_to_DataFrame,\n \"edge_1_to_2\":DataFrame_to_AsciiDataTable}\n self.options={}\n for key,value in defaults.items():\n self.options[key]=value\n for key,value in options.items():\n self.options[key]=value\n Graph.__init__(self,**self.options)\n self.add_node(\"HdfFile\",\"DataFrame\",DataFrame_to_HdfFile,\n \"DataFrame\",HdfFile_to_DataFrame,\n node_description=\"HDF File\")\n self.add_node(\"XmlDataTable\",\"AsciiDataTable\",AsciiDataTable_to_XmlDataTable,\n \"AsciiDataTable\",XmlDataTable_to_AsciiDataTable,\n node_description=\"XML Data Table\")\n # Need to add XML File and Html File using save and save_HTML()\n self.add_node(\"ExcelFile\",\"DataFrame\",DataFrame_to_ExcelFile,\n \"DataFrame\",ExcelFile_to_DataFrame,\n node_description=\"Excel File\")\n\n self.add_node(\"OdsFile\",\"ExcelFile\",ExcelFile_to_OdsFile,\n \"ExcelFile\",OdsFile_to_ExcelFile,\"Open Office Spreadsheet\")\n\n self.add_node(\"HtmlString\",\"DataFrame\",DataFrame_to_HtmlString,\n \"DataFrame\",HtmlString_to_DataFrame,\n node_description=\"HTML String\")\n # Note a lot of the pandas reading and writing cause float64 round off errors\n # applymap(lambda x: np.around(x,10) any all float fields will fix this\n # also the column names move about in order\n self.add_node(\"JsonFile\",\"DataFrame\",DataFrame_to_JsonFile,\n \"DataFrame\",JsonFile_to_DataFrame,\n node_description=\"JSON File\")\n self.add_node(\"JsonString\",\"DataFrame\",DataFrame_to_JsonString,\n \"DataFrame\",JsonString_to_DataFrame,\n node_description=\"JSON String\")\n self.add_node(\"CsvFile\",\"DataFrame\",DataFrame_to_CsvFile,\n \"DataFrame\",CsvFile_to_DataFrame,\n node_description=\"CSV File\")\n self.add_node(\"MatFile\",\"AsciiDataTable\",AsciiTable_to_MatFile,\n \"AsciiDataTable\",MatFile_to_AsciiTable,\n node_description=\"Matlab File\")\n self.add_node(\"XmlFile\",\"XmlDataTable\",XmlDataTable_to_XmlFile,\n \"XmlDataTable\",XmlFile_to_XmlDataTable,\n node_description=\"XML DataTable Saved As a File\")\n self.add_node(\"HtmlFile\",\"HtmlString\",HtmlString_to_HtmlFile,\n \"HtmlString\",HtmlFile_to_HtmlString,\n node_description=\"HTML File\")\n self.add_edge(\"DataFrame\",\"HtmlFile\",DataFrame_to_HtmlFile)\n self.add_edge(\"JsonFile\",\"XmlDataTable\",JsonFile_to_XmlDataTable)\n self.add_external_node(\"XsltResultString\",\"XmlDataTable\",XmlBase_to_XsltResultString,\n external_node_description=\"XSLT Results String\")\n self.add_external_node(\"XsltResultFile\",\"XmlDataTable\",XmlBase_to_XsltResultFile,\n external_node_description=\"XSLT Results File\")\nclass ImageGraph(Graph):\n \"\"\"A transformation graph for images node types are image formats and external nodes are\n common image processing functions\n #!python\n defaults={\"graph_name\":\"Image Graph\",\n \"node_names\":['Image','png'],\n \"node_descriptions\":[\"PIL Image\",\"png\"],\n \"current_node\":'Image',\n \"state\":[1,0],\n \"data\":PIL.Image.open(os.path.join(TESTS_DIRECTORY,'test.png')),\n \"edge_2_to_1\":File_to_Image,\n \"edge_1_to_2\":lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"png\")}\n \"\"\"\n def __init__(self,**options):\n defaults={\"graph_name\":\"Image Graph\",\n \"node_names\":['Image','Png'],\n \"node_descriptions\":[\"PIL Image\",\"Png\"],\n \"current_node\":'Image',\n \"state\":[1,0],\n \"data\":PIL.Image.open(os.path.join(TESTS_DIRECTORY,'test.png')),\n \"edge_2_to_1\":File_to_Image,\n \"edge_1_to_2\":lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"png\")}\n self.options={}\n for key,value in defaults.items():\n self.options[key]=value\n for key,value in options.items():\n self.options[key]=value\n Graph.__init__(self,**self.options)\n self.add_node(\"Jpg\",\"Image\",lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"jpg\"),\n \"Image\",File_to_Image,node_description=\"Jpg File\")\n self.add_node(\"Tiff\",\"Image\",lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"tiff\"),\n \"Image\",File_to_Image,node_description=\"Tif File\")\n self.add_node(\"Gif\",\"Image\",lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"gif\"),\n \"Image\",File_to_Image,node_description=\"Gif File\")\n self.add_node(\"Bmp\",\"Image\",lambda x: Image_to_FileType(x,file_path=\"test\",extension=\"bmp\"),\n \"Image\",File_to_Image,node_description=\"BMP File\")\n self.add_node(\"Base64\",\"Png\",PngFile_to_Base64,\n \"Png\",Base64_to_PngFile,node_description=\"Base 64 PNG\")\n self.add_node(\"EmbeddedHtml\",\"Base64\",Base64Png_to_EmbeddedHtmlString,\n \"Base64\",EmbeddedHtmlString_to_Base64Png,node_description=\"Embedded HTML of PNG\")\n self.add_node(\"Ndarray\",\"Png\",PngFile_to_Ndarray,\n \"Png\",Ndarray_to_PngFile,node_description=\"Numpy Array\")\n self.add_node(\"MatplotlibFigure\",\"Ndarray\",Ndarray_to_MatplotlibFigure,\n \"Png\",MatplotlibFigure_to_PngFile,node_description=\"MatplotlibFigure\")\n self.add_external_node(\"Thumbnail\",\"Image\",Image_to_ThumbnailFile,external_node_description=\"JPEG Thumbnail\")\n self.add_external_node(\"Matplotlib\",\"Ndarray\",Ndarray_to_Matplotlib,\n external_node_description=\"Matplotlib Plot\")\n\nclass MetadataGraph(Graph):\n \"\"\"Metadata Graph is a graph representing the content of key,value metadata\"\"\"\n def __init__(self,**options):\n \"\"\"Intializes the metadata graph class\"\"\"\n defaults={\"graph_name\":\"Metadata Graph\",\n \"node_names\":['Dictionary','JsonString'],\n \"node_descriptions\":[\"Python Dictionary\",\"Json string\"],\n \"current_node\":'Dictionary',\n \"state\":[1,0],\n \"data\":{\"a\":\"First\",\"b\":\"Second\"},\n \"edge_2_to_1\":JsonString_to_Dictionary,\n \"edge_1_to_2\":Dictionary_to_JsonString}\n self.options={}\n for key,value in defaults.items():\n self.options[key]=value\n for key,value in options.items():\n self.options[key]=value\n Graph.__init__(self,**self.options)\n self.add_node(\"JsonFile\",\"JsonString\",JsonString_to_JsonFile,\n \"JsonString\",JsonFile_to_JsonString,node_description=\"JSON File\")\n self.add_node(\"XmlString\",\"Dictionary\",Dictionary_to_XmlString,\n \"Dictionary\",XmlString_to_Dictionary,node_description=\"XML string\")\n self.add_node(\"HtmlMetaString\",\"Dictionary\",Dictionary_to_HtmlMetaString,\n \"Dictionary\",HtmlMetaString_to_Dictionary,node_description=\"HTML meta tags\")\n self.add_node(\"XmlTupleString\",\"Dictionary\",Dictionary_to_XmlTupleString,\n \"Dictionary\",XmlTupleString_to_Dictionary,node_description=\"Tuple Line\")\n self.add_node(\"PickleFile\",\"Dictionary\",Dictionary_to_PickleFile,\n \"Dictionary\",PickleFile_to_Dictionary,node_description=\"Pickled File\")\n self.add_node(\"ListList\",\"Dictionary\",Dictionary_to_ListList,\n \"Dictionary\",ListList_to_Dictionary,node_description=\"List of lists\")\n self.add_node(\"HeaderList\",\"Dictionary\",Dictionary_to_HeaderList,\n \"Dictionary\",HeaderList_to_Dictionary,node_description=\"Header List\")\n self.add_node(\"DataFrame\",\"Dictionary\",Dictionary_to_DataFrame,\n \"Dictionary\",DataFrame_to_Dictionary,node_description=\"Pandas DataFrame\")\n self.add_node(\"AsciiDataTable\",\"DataFrame\",DataFrame_to_AsciiDataTable,\n \"DataFrame\",AsciiDataTable_to_DataFrame,node_description=\"AsciiDataTable\")\n self.add_node(\"MatFile\",\"AsciiDataTable\",AsciiTable_to_MatFile,\n \"AsciiDataTable\",MatFile_to_AsciiDataTableKeyValue,node_description=\"Matlab\")\n self.add_node(\"ExcelFile\",\"DataFrame\",DataFrame_to_ExcelFile,\n \"DataFrame\",ExcelFile_to_DataFrame,node_description=\"excel\")\n self.add_node(\"HdfFile\",\"DataFrame\",DataFrame_to_HdfFile,\n \"DataFrame\",HdfFile_to_DataFrame,node_description=\"hdf file\")\n self.add_node(\"CsvFile\",\"DataFrame\",DataFrame_to_CsvFile,\n \"DataFrame\",CsvFile_to_DataFrame,node_description=\"CSV File\")\n self.add_node(\"HtmlFile\",\"DataFrame\",DataFrame_to_HtmlFile,\n \"DataFrame\",HtmlFile_to_DataFrame,node_description=\"HTML Table File\")\n self.add_node(\"HtmlTableString\",\"HtmlFile\",HtmlFile_to_HtmlString,\n \"HtmlFile\",HtmlString_to_HtmlFile,node_description=\"HTML Table String\")\nclass TwoPortParameterGraph(Graph):\n \"\"\"TwoPortParamterGraph is a content graph for two-port parameters,\n it transforms between S,T,Y,Z,ABCD and H parameters and matrix versions.\n #!python\n defaults={\"graph_name\":\"Two Port Parameter Graph\",\n \"node_names\":[\"SFrequencyList\",'SFrequencyMatrixList'],\n \"node_descriptions\":[\"S Parameters\",\"S Parameters in a Matrix\"],\n \"current_node\":'SFrequencyList',\n \"state\":[1,0],\n \"data\":[[1.0,.9,.436,.436,.9]],\n \"edge_2_to_1\":FrequencyMatrixList_to_FrequencyList,\n \"edge_1_to_2\":FrequencyList_to_FrequencyMatrixList,\n \"frequency_units\":\"GHz\",\n \"Z01\":50,\n \"Z02\":50 }\n\"\"\"\n def __init__(self,**options):\n\n defaults={\"graph_name\":\"Two Port Parameter Graph\",\n \"node_names\":[\"SFrequencyList\",'SFrequencyMatrixList'],\n \"node_descriptions\":[\"S Parameters\",\"S Parameters in a Matrix\"],\n \"current_node\":'SFrequencyList',\n \"state\":[1,0],\n \"data\":[[1.0,.9,.436,.436,.9]],\n \"edge_2_to_1\":FrequencyMatrixList_to_FrequencyList,\n \"edge_1_to_2\":FrequencyList_to_FrequencyMatrixList,\n \"frequency_units\":\"GHz\",\n \"Z01\":50,\n \"Z02\":50 }\n graph_options={}\n for key,value in defaults.items():\n graph_options[key]=value\n for key,value in options.items():\n graph_options[key]=value\n Graph.__init__(self,**graph_options)\n\n self.add_node(\"TFrequencyMatrixList\",\n \"SFrequencyMatrixList\",SFrequencyMatrixList_to_TFrequencyMatrixList,\n \"SFrequencyMatrixList\",TFrequencyMatrixList_to_SFrequencyMatrixList,\n \"T Parameters in a Matrix\")\n\n self.add_node(\"TFrequencyList\",\n \"TFrequencyMatrixList\",FrequencyMatrixList_to_FrequencyList,\n \"TFrequencyMatrixList\",FrequencyList_to_FrequencyMatrixList,\n \"T Parameters\")\n\n self.add_node(\"ZFrequencyList\",\n \"SFrequencyList\",SFrequencyList_to_ZFrequencyList,\n \"TFrequencyList\",ZFrequencyList_to_TFrequencyList,\n \"Z Parameters\")\n\n self.add_node(\"ZFrequencyMatrixList\",\n \"ZFrequencyList\",FrequencyList_to_FrequencyMatrixList,\n \"ZFrequencyList\",FrequencyMatrixList_to_FrequencyList,\n \"Z Parameters in a matrix\")\n\n self.add_node(\"ABCDFrequencyList\",\n \"ZFrequencyList\",ZFrequencyList_to_ABCDFrequencyList,\n \"ZFrequencyList\",ABCDFrequencyList_to_ZFrequencyList,\n \"ABCD Parameters\")\n\n self.add_node(\"ABCDFrequencyMatrixList\",\n \"ABCDFrequencyList\",FrequencyList_to_FrequencyMatrixList,\n \"ABCDFrequencyList\",FrequencyMatrixList_to_FrequencyList,\n \"ABCD Parameters in a matrix\")\n\n self.add_node(\"HFrequencyList\",\n \"ABCDFrequencyList\",ABCDFrequencyList_to_HFrequencyList,\n \"ZFrequencyList\",HFrequencyList_to_ZFrequencyList,\n \"h Parameters\")\n\n self.add_node(\"HFrequencyMatrixList\",\n \"HFrequencyList\",FrequencyList_to_FrequencyMatrixList,\n \"HFrequencyList\",FrequencyMatrixList_to_FrequencyList,\n \"H Parameters in a matrix\")\n self.add_node(\"YFrequencyList\",\n \"ABCDFrequencyList\",ABCDFrequencyList_to_YFrequencyList,\n \"HFrequencyList\",YFrequencyList_to_HFrequencyList,\n \"Y Parameters\")\n\n self.add_node(\"YFrequencyMatrixList\",\n \"YFrequencyList\",FrequencyList_to_FrequencyMatrixList,\n \"YFrequencyList\",FrequencyMatrixList_to_FrequencyList,\n \"Y Parameters in a matrix\")\n\n self.add_edge(begin_node=\"ZFrequencyMatrixList\",\n end_node=\"YFrequencyMatrixList\",\n edge_function=ZFrequencyMatrixList_to_YFrequencyMatrixList)\n\n self.add_edge(begin_node=\"SFrequencyMatrixList\",\n end_node=\"ZFrequencyMatrixList\",\n edge_function=SFrequencyMatrixList_to_ZFrequencyMatrixList)\n\n self.add_edge(begin_node=\"ZFrequencyMatrixList\",\n end_node=\"TFrequencyMatrixList\",\n edge_function=ZFrequencyMatrixList_to_TFrequencyMatrixList)\n\n self.add_edge(begin_node=\"ABCDFrequencyList\",\n end_node=\"SFrequencyList\",\n edge_function=ABCDFrequencyList_to_SFrequencyList)\nclass DataTableGraph(Graph):\n \"\"\" Class that transforms a row modelled header and metadata to several different data types\n #!python\n defaults={\"graph_name\":\"Data Table Graph\",\n \"node_names\":['DataFrameDictionary','AsciiDataTable'],\n \"node_descriptions\":[\"Pandas Data Frame Dictionary\",\"AsciiDataTable\"],\n \"current_node\":'DataFrameDictionary',\n \"state\":[1,0],\n \"data\":AsciiDataTable_to_DataFrameDictionary(TwoPortRawModel(os.path.join(TESTS_DIRECTORY,'TestFileTwoPortRaw.txt'))),\n \"edge_2_to_1\":AsciiDataTable_to_DataFrameDictionary,\n \"edge_1_to_2\":DataFrameDictionary_to_AsciiDataTable\n }\n \"\"\"\n def __init__(self,**options):\n\n defaults={\"graph_name\":\"Data Table Graph\",\n \"node_names\":['DataFrameDictionary','AsciiDataTable'],\n \"node_descriptions\":[\"Pandas Data Frame Dictionary\",\"AsciiDataTable\"],\n \"current_node\":'DataFrameDictionary',\n \"state\":[1,0],\n \"data\":AsciiDataTable_to_DataFrameDictionary(TwoPortRawModel(os.path.join(TESTS_DIRECTORY,'TestFileTwoPortRaw.txt'))),\n \"edge_2_to_1\":AsciiDataTable_to_DataFrameDictionary,\n \"edge_1_to_2\":DataFrameDictionary_to_AsciiDataTable\n }\n graph_options={}\n for key,value in defaults.items():\n graph_options[key]=value\n for key,value in options.items():\n graph_options[key]=value\n Graph.__init__(self, **graph_options)\n\n self.add_node(\"ExcelFile\", \"DataFrameDictionary\", DataFrameDictionary_to_ExcelFile,\n \"DataFrameDictionary\", ExcelFile_to_DataFrameDictionary,\n node_description=\"Excel Workbook\")\n self.add_node(\"HdfFile\", \"DataFrameDictionary\", DataFrameDictionary_to_HdfFile,\n \"DataFrameDictionary\", HdfFile_to_DataFrameDictionary, node_description=\"HD5 File\")\n self.add_node(\"CsvFile\", \"AsciiDataTable\", AsciiDataTable_to_CsvFile,\n \"AsciiDataTable\", File_to_AsciiDataTable, node_description=\"CSV File\")\n self.add_node(\"HpFile\", \"AsciiDataTable\", AsciiDataTable_to_HpFile,\n \"AsciiDataTable\", File_to_AsciiDataTable, node_description=\"hp format File\")\n self.add_external_node(external_node_name=\"XMLDataTable\", jump_into_node_begin=\"AsciiDataTable\",\n jump_into_node_function=AsciiDataTable_to_XmlDataTable,\n external_node_description=\"XMLDataTable\")\n#-----------------------------------------------------------------------------\n# Module Scripts\n#TODO: Add test_Graph script currently lives in jupyter-notebooks\n\n#-----------------------------------------------------------------------------\n# Module Runner\nif __name__ == '__main__':\n pass"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":20,"numItemsPerPage":100,"numTotalItems":2760,"offset":2000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6Im1sR1pFYktIVHRVSGRhX1RRdEczQ0N1S3k5ME9Qd25DNHY5elRjM3FVYzgifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MzAxMjQ0NCwianRpIjoiM2FiMmZkMmEtYzkyNy00MGY2LWExNmUtN2FkZTM4Y2QxMjhlIiwic3ViIjoiL2RhdGFzZXRzL0FTU0VSVC1LVEgvc3RhY2stc21vbC1kb2NzdHJpbmdzIiwiZXhwIjoxNzgzMDE2MDQ0LCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.sOye0I6XKHOUo3QvKHF-XNpNUvzON88gFYbdJZWR_WHtOWLv1-EDtsxrnZ0_IkMabYMhs4L8Epad790D2EJoCg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":2760,"numBytesParquet":64655948}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
function_name stringlengths 1 63 | docstring stringlengths 50 5.89k | masked_code stringlengths 50 882k | implementation stringlengths 169 12.9k | start_line int32 1 14.6k | end_line int32 16 14.6k | file_content stringlengths 274 882k |
|---|---|---|---|---|---|---|
read_go_deps | read_go_deps returns a list of module dependencies in JSON format.
Main modules are excluded; only dependencies are returned.
Unlike `go list -m all`, this function excludes modules that are only
required for running tests. | from __future__ import print_function
import glob
import os
import datetime
import argparse
import json
import csv
import re
import pdb
import copy
import subprocess
import fnmatch
import textwrap
import sys
import tempfile
DEFAULT_BUILD_TAGS = "darwin,linux,windows"
# Get the beats repo root directory, making sure ... | def read_go_deps(main_packages, build_tags):
"""
read_go_deps returns a list of module dependencies in JSON format.
Main modules are excluded; only dependencies are returned.
Unlike `go list -m all`, this function excludes modules that are only
required for running tests.
"""
go_list_args =... | 40 | 65 | from __future__ import print_function
import glob
import os
import datetime
import argparse
import json
import csv
import re
import pdb
import copy
import subprocess
import fnmatch
import textwrap
import sys
import tempfile
DEFAULT_BUILD_TAGS = "darwin,linux,windows"
# Get the beats repo root directory, making sure ... |
__init__ | Initialize the DPOptimizerClass.
Args:
l2_norm_clip: Clipping norm (max L2 norm of per microbatch gradients)
noise_multiplier: Ratio of the standard deviation to the clipping norm
num_microbatches: The number of microbatches into which each minibatch
is split. | # Copyright 2020 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | def __init__(
self,
l2_norm_clip,
noise_multiplier,
changing_clipping=False,
num_microbatches=None,
gradient_norm=None,
*args, # pylint: disable=keyword-arg-before-vararg, g-doc-args
**kwargs):
"""Initialize the DPOptimizerClass.
Args:
... | 44 | 71 | # Copyright 2020 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
algebraic_connectivity | Return the algebraic connectivity of an undirected graph.
The algebraic connectivity of a connected undirected graph is the second
smallest eigenvalue of its Laplacian matrix.
Parameters
----------
G : NetworkX graph
An undirected graph.
weight : object, optional (default: None)
The data key used to determin... | # -*- coding: utf-8 -*-
# Copyright (C) 2014 ysitu <ysitu@users.noreply.github.com>
# All rights reserved.
# BSD license.
#
# Author: ysitu <ysitu@users.noreply.github.com>
"""
Algebraic connectivity and Fiedler vectors of undirected graphs.
"""
from functools import partial
import networkx as nx
from networkx.utils im... | @not_implemented_for('directed')
def algebraic_connectivity(G, weight='weight', normalized=False, tol=1e-8,
method='tracemin_pcg'):
"""Return the algebraic connectivity of an undirected graph.
The algebraic connectivity of a connected undirected graph is the second
smallest eigen... | 330 | 407 | # -*- coding: utf-8 -*-
# Copyright (C) 2014 ysitu <ysitu@users.noreply.github.com>
# All rights reserved.
# BSD license.
#
# Author: ysitu <ysitu@users.noreply.github.com>
"""
Algebraic connectivity and Fiedler vectors of undirected graphs.
"""
from functools import partial
import networkx as nx
from networkx.utils im... |
fiedler_vector | Return the Fiedler vector of a connected undirected graph.
The Fiedler vector of a connected undirected graph is the eigenvector
corresponding to the second smallest eigenvalue of the Laplacian matrix of
of the graph.
Parameters
----------
G : NetworkX graph
An undirected graph.
weight : object, optional (defaul... | # -*- coding: utf-8 -*-
# Copyright (C) 2014 ysitu <ysitu@users.noreply.github.com>
# All rights reserved.
# BSD license.
#
# Author: ysitu <ysitu@users.noreply.github.com>
"""
Algebraic connectivity and Fiedler vectors of undirected graphs.
"""
from functools import partial
import networkx as nx
from networkx.utils im... | @not_implemented_for('directed')
def fiedler_vector(G, weight='weight', normalized=False, tol=1e-8,
method='tracemin_pcg'):
"""Return the Fiedler vector of a connected undirected graph.
The Fiedler vector of a connected undirected graph is the eigenvector
corresponding to the second smal... | 410 | 488 | # -*- coding: utf-8 -*-
# Copyright (C) 2014 ysitu <ysitu@users.noreply.github.com>
# All rights reserved.
# BSD license.
#
# Author: ysitu <ysitu@users.noreply.github.com>
"""
Algebraic connectivity and Fiedler vectors of undirected graphs.
"""
from functools import partial
import networkx as nx
from networkx.utils im... |
base_setup | A setup phase for the test
Args:
interface_type: Interface type
storageclass_factory: A fixture to create everything needed for a storage class | """
Test to verify performance of attaching number of pods as a bulk, each pod attached to one pvc only
The test results will be uploaded to the ES server
"""
import logging
import os
import pytest
import pathlib
import time
from concurrent.futures import ThreadPoolExecutor
from ocs_ci.framework.testlib import perform... | @pytest.fixture()
def base_setup(self, project_factory, interface_type, storageclass_factory):
"""
A setup phase for the test
Args:
interface_type: Interface type
storageclass_factory: A fixture to create everything needed for a storage class
"""
... | 45 | 63 | """
Test to verify performance of attaching number of pods as a bulk, each pod attached to one pvc only
The test results will be uploaded to the ES server
"""
import logging
import os
import pytest
import pathlib
import time
from concurrent.futures import ThreadPoolExecutor
from ocs_ci.framework.testlib import perform... |
init_full_results | Initialize the full results object which will send to the ES server
Args:
full_results (obj): an empty ResultsAnalyse object
Returns:
ResultsAnalyse (obj): the input object filled with data | """
Test to verify performance of attaching number of pods as a bulk, each pod attached to one pvc only
The test results will be uploaded to the ES server
"""
import logging
import os
import pytest
import pathlib
import time
from concurrent.futures import ThreadPoolExecutor
from ocs_ci.framework.testlib import perform... | def init_full_results(self, full_results):
"""
Initialize the full results object which will send to the ES server
Args:
full_results (obj): an empty ResultsAnalyse object
Returns:
ResultsAnalyse (obj): the input object filled with data
"""
... | 226 | 240 | """
Test to verify performance of attaching number of pods as a bulk, each pod attached to one pvc only
The test results will be uploaded to the ES server
"""
import logging
import os
import pytest
import pathlib
import time
from concurrent.futures import ThreadPoolExecutor
from ocs_ci.framework.testlib import perform... |
add_active_repository | Adds a new active repository identified by 'repository_id' and that uses 'plan' as base.
Args:
repository_id (str): The ID to give to the repository. This must be unique, if it is not an error will be
returned.
plan (str): The name of the plan to use as base for the repository. If it does not exist the... | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... | def add_active_repository(self, repository_id: str, plan: str, archive: str, **kwargs):
"""Adds a new active repository identified by 'repository_id' and that uses 'plan' as base.
Args:
repository_id (str): The ID to give to the repository. This must be unique, if it is not an error wil... | 5,063 | 5,108 | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... |
check_cloud_params | Checks that inside kwargs there is a valid set of parameters to add a cloud repository
Args:
archive (str): The archive to use for the repository. | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... | @staticmethod
def check_cloud_params(archive: str, **kwargs) -> Optional[List[str]]:
"""Checks that inside kwargs there is a valid set of parameters to add a cloud repository
Args:
archive (str): The archive to use for the repository.
"""
# If not an s3 archive skip t... | 5,110 | 5,134 | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... |
archive_repository | Archive an repository. The archived repository will have the id `new_id`
Args:
repository_id (str): The active repository ID to be archived
new_id (str): The id that will be given to the archived repository | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... | def archive_repository(self, repository_id, new_id):
"""Archive an repository. The archived repository will have the id `new_id`
Args:
repository_id (str): The active repository ID to be archived
new_id (str): The id that will be given to the archived repository
"""
... | 5,136 | 5,150 | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... |
list_repositories | List the backup repositories.
If a repository state is given only repositories in that state will be listed. This command supports listing both in
json and human friendly format.
Args:
state (str, optional): One of ['active', 'imported', 'archived']. The repository on this state will be
retrieved.
jso... | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... | def list_repositories(self, state=None, json_out=False):
"""List the backup repositories.
If a repository state is given only repositories in that state will be listed. This command supports listing both in
json and human friendly format.
Args:
state (str, optional): On... | 5,152 | 5,173 | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... |
human_firendly_print_repository | Print the repository in a human friendly format
Args:
repository (obj): The backup repository information | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... | @staticmethod
def human_firendly_print_repository(repository):
"""Print the repository in a human friendly format
Args:
repository (obj): The backup repository information
"""
print(f'ID: {repository["id"]}')
print(f'State: {repository["state"]}')
pr... | 5,197 | 5,224 | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... |
human_friendly_print_running_tasks | Prints the running task summary in a human friendly way
Args:
one_off (map<str, task object>): Running one off tasks
scheduled (map<str, task object>): Running scheduled tasks | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... | @staticmethod
def human_friendly_print_running_tasks(one_off, scheduled):
"""Prints the running task summary in a human friendly way
Args:
one_off (map<str, task object>): Running one off tasks
scheduled (map<str, task object>): Running scheduled tasks
"""
... | 5,226 | 5,254 | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... |
human_friendly_print_repositories | This will print the repositories in a tabular format
Args:
repository_map (map<state (str), repository (list of objects)>) | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... | @staticmethod
def human_friendly_print_repositories(repositories_map):
"""This will print the repositories in a tabular format
Args:
repository_map (map<state (str), repository (list of objects)>)
"""
repository_count = 0
id_pad = 5
plan_pad = 7
... | 5,273 | 5,314 | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... |
add_plan | Add a new backup plan
The validation of the inputs in the CLI is intentionally lacking as this is offloaded to the backup service.
Args:
name (str): The name to give the new plan. It must be unique.
services (optional list): A list of services to backup if empty all services are backed up.
tasks (optional ... | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... | def add_plan(self, name: str, services: Optional[str], tasks: Optional[List[str]], description: Optional[str]):
"""Add a new backup plan
The validation of the inputs in the CLI is intentionally lacking as this is offloaded to the backup service.
Args:
name (str): The name to giv... | 5,367 | 5,403 | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... |
get_plan | Gets a backup plan by name
Args:
name (str): The name of the plan to retrieve
json_output (bool): Whether to print in JSON or a more human friendly way | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... | def get_plan(self, name: str, json_output: bool = False):
"""Gets a backup plan by name
Args:
name (str): The name of the plan to retrieve
json_output (bool): Whether to print in JSON or a more human friendly way
"""
if not name:
_exit_if_errors([... | 5,414 | 5,429 | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... |
list_plans | Prints all the plans stored in the backup service
Args:
json_output (bool): Whether to print in JSON or a more human friendly way | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... | def list_plans(self, json_output: bool = False):
"""Prints all the plans stored in the backup service
Args:
json_output (bool): Whether to print in JSON or a more human friendly way
"""
plans, errors = self.rest.list_backup_plans()
_exit_if_errors(errors)
... | 5,431 | 5,442 | """A Couchbase CLI subcommand"""
import getpass
import inspect
import ipaddress
import json
import os
import platform
import random
import re
import string
import subprocess
import sys
import urllib.parse
import tempfile
import time
from typing import Optional, List, Any, Dict
from argparse import ArgumentError, Arg... |
__init__ | Input properties used for looking up and filtering GroupMemberships resources.
:param pulumi.Input[str] group_id: ID of a Okta group.
:param pulumi.Input[Sequence[pulumi.Input[str]]] users: The list of Okta user IDs which the group should have membership managed for. | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import ... | def __init__(__self__, *,
group_id: Optional[pulumi.Input[str]] = None,
users: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
"""
Input properties used for looking up and filtering GroupMemberships resources.
:param pulumi.Input[str] group_id: ... | 53 | 64 | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import ... |
get | Get an existing GroupMemberships resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Op... | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import ... | @staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None,
group_id: Optional[pulumi.Input[str]] = None,
users: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None) -> 'GroupMemberships':
"""
... | 195 | 217 | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import ... |
gen_attributes | Generate list of attributes for the API request.
Example of input list:
['tag_name:tag_value1', 'tag_value2']
Output of the function for the given input list:
[{'key': 'tag_name', 'value': 'tag_value1'}, {'value': 'tag_value2'}]
:param rp_attributes: List of attributes(tags)
:return: Correctly created li... | """This module contains common functions-helpers of the client and agents.
Copyright (c) 2018 http://reportportal.io .
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/... | def gen_attributes(rp_attributes):
"""Generate list of attributes for the API request.
Example of input list:
['tag_name:tag_value1', 'tag_value2']
Output of the function for the given input list:
[{'key': 'tag_name', 'value': 'tag_value1'}, {'value': 'tag_value2'}]
:param rp_attributes: List ... | 22 | 48 | """This module contains common functions-helpers of the client and agents.
Copyright (c) 2018 http://reportportal.io .
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/... |
neighbord_analysis | Given an array xas this function compute the distance between the elements the mean distance and the variance
Author: Michele Monti
Args:
x_as: the name of the list or data set that you want:
Kwargs:
column: is the column of the data set that you need to analyze
Returns:
mean_distanc... | # MASKED: neighbord_analysis function (lines 1-28) | def neighbord_analysis(x_as, column = 0):
"""
Given an array xas this function compute the distance between the elements the mean distance and the variance
Author: Michele Monti
Args:
x_as: the name of the list or data set that you want:
Kwargs:
column: is the column of the data set that you need to ana... | 1 | 28 | def neighbord_analysis(x_as, column = 0):
"""
Given an array xas this function compute the distance between the elements the mean distance and the variance
Author: Michele Monti
Args:
x_as: the name of the list or data set that you want:
Kwargs:
column: is the column of the data set that you need to ana... |
start_training | Executes a training function on all workers in a separate thread.
``finish_training`` should be called after this.
Args:
train_func (Callable): The training function to run on each worker. | import logging
from typing import Callable, TypeVar, List, Optional, Dict
import ray
from ray.exceptions import RayActorError
from ray.util.sgd.v2.worker_group import WorkerGroup
from ray.util.sgd.v2.session import init_session, get_session, shutdown_session
T = TypeVar("T")
logger = logging.getLogger(__name__)
cl... | def start_training(self, train_func: Callable[[], T]) -> None:
"""Executes a training function on all workers in a separate thread.
``finish_training`` should be called after this.
Args:
train_func (Callable): The training function to run on each worker.
"""
# ... | 63 | 99 | import logging
from typing import Callable, TypeVar, List, Optional, Dict
import ray
from ray.exceptions import RayActorError
from ray.util.sgd.v2.worker_group import WorkerGroup
from ray.util.sgd.v2.session import init_session, get_session, shutdown_session
T = TypeVar("T")
logger = logging.getLogger(__name__)
cl... |
__init__ | Creates a _TreeEnsembleSavable object.
Args:
resource_handle: handle to the decision tree ensemble variable.
create_op: the op to initialize the variable.
name: the name to save the tree ensemble variable under. | # Copyright 2018 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | def __init__(self, resource_handle, create_op, name):
"""Creates a _TreeEnsembleSavable object.
Args:
resource_handle: handle to the decision tree ensemble variable.
create_op: the op to initialize the variable.
name: the name to save the tree ensemble variable under.
"""
stamp_toke... | 169 | 191 | # Copyright 2018 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
promote_ase_atoms | Convert ASE Atoms object to the one usable by SPRKKR.
For the case of the usability it is a bit ugly hack: The __class__ attribute
is replaced so the extra methods and properties of the objects will
be available.
Parameters
----------
obj: ase.Atoms
The atoms object to be promoted to be used for SPRKKR calculations
... | """ This file contains SPRKKRAtoms - an enhanced version of Atoms to be used
with SPRKKR """
from ase import Atoms
from ..common.unique_values import UniqueValuesMapping
import spglib
from ase.spacegroup import Spacegroup
import numpy as np
from ..sprkkr.sites import Site
from ..common.misc import numpy_index
class ... | @staticmethod
def promote_ase_atoms(obj, symmetry=None):
""" Convert ASE Atoms object to the one usable by SPRKKR.
For the case of the usability it is a bit ugly hack: The __class__ attribute
is replaced so the extra methods and properties of the objects will
be available.
... | 16 | 49 | """ This file contains SPRKKRAtoms - an enhanced version of Atoms to be used
with SPRKKR """
from ase import Atoms
from ..common.unique_values import UniqueValuesMapping
import spglib
from ase.spacegroup import Spacegroup
import numpy as np
from ..sprkkr.sites import Site
from ..common.misc import numpy_index
class ... |
_type_repr | Return the repr() of an object, special-casing types (internal helper).
If obj is a type, we return a shorter version than the default
type.__repr__, based on the module and qualified name, which is
typically enough to uniquely identify a type. For everything
else, we fall back on repr(obj). | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from torch.f... | def _type_repr(obj):
"""Return the repr() of an object, special-casing types (internal helper).
If obj is a type, we return a shorter version than the default
type.__repr__, based on the module and qualified name, which is
typically enough to uniquely identify a type. For everything
else, we fall b... | 44 | 63 | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from ... |
__init__ | Instantiate an instance of ``Node``. Note: most often, you want to use the
Graph APIs, i.e. ``Graph.call_module``, ``Graph.call_method``, etc. rather
than instantiating a ``Node`` directly.
Args:
graph (Graph): The ``Graph`` to which this ``Node`` should belong.
name (str): The name to which the output of thi... | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from torch.f... | @compatibility(is_backward_compatible=True)
def __init__(self, graph: 'Graph', name: str, op: str, target: 'Target',
args: Tuple['Argument', ...], kwargs: Dict[str, 'Argument'],
return_type : Optional[Any] = None) -> None:
"""
Instantiate an instance of ``Node``... | 120 | 198 | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from ... |
_pretty_print_target | Make target printouts more user-friendly.
1) builtins will be printed as `builtins.xyz`
2) operators will be printed as `operator.xyz`
3) other callables will be printed with qualfied name, e.g. torch.add | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from torch.f... | def _pretty_print_target(self, target):
"""
Make target printouts more user-friendly.
1) builtins will be printed as `builtins.xyz`
2) operators will be printed as `operator.xyz`
3) other callables will be printed with qualfied name, e.g. torch.add
"""
if isin... | 382 | 402 | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from ... |
replace_all_uses_with | Replace all uses of ``self`` in the Graph with the Node ``replace_with``.
Args:
replace_with (Node): The node to replace all uses of ``self`` with.
Returns:
The list of Nodes on which this change was made. | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from torch.f... | @compatibility(is_backward_compatible=True)
def replace_all_uses_with(self, replace_with : 'Node') -> List['Node']:
"""
Replace all uses of ``self`` in the Graph with the Node ``replace_with``.
Args:
replace_with (Node): The node to replace all uses of ``self`` with.
... | 460 | 488 | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from ... |
is_impure | Returns whether this op is impure, i.e. if its op is a placeholder or
output, or if a call_function or call_module which is impure.
Returns:
bool: If the op is impure or not. | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from torch.f... | @compatibility(is_backward_compatible=False)
def is_impure(self):
"""
Returns whether this op is impure, i.e. if its op is a placeholder or
output, or if a call_function or call_module which is impure.
Returns:
bool: If the op is impure or not.
"""
i... | 490 | 518 | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from ... |
normalized_arguments | Returns normalized arguments to Python targets. This means that
`args/kwargs` will be matched up to the module/functional's
signature and return exclusively kwargs in positional order
if `normalize_to_only_use_kwargs` is true.
Also populates default values. Does not support positional-only
parameters or varargs paramet... | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from torch.f... | @compatibility(is_backward_compatible=False)
def normalized_arguments(
self, root : torch.nn.Module, arg_types : Optional[Tuple[Any]] = None,
kwarg_types : Optional[Dict[str, Any]] = None,
normalize_to_only_use_kwargs : bool = False) -> Optional[ArgsKwargsPair]:
"""
... | 520 | 554 | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from ... |
replace_input_with | Loop through input nodes of ``self``, and replace all instances of
``old_input`` with ``new_input``.
Args:
old_input (Node): The old input node to be replaced.
new_input (Node): The new input node to replace ``old_input``. | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from torch.f... | @compatibility(is_backward_compatible=True)
def replace_input_with(self, old_input: 'Node', new_input: 'Node'):
"""
Loop through input nodes of ``self``, and replace all instances of
``old_input`` with ``new_input``.
Args:
old_input (Node): The old input node to be ... | 556 | 574 | # Nodes represent a definition of a value in our graph of operators.
from typing import TYPE_CHECKING, Union, Callable, Any, Tuple, List, Optional, Dict, Set
from ._compatibility import compatibility
from .immutable_collections import immutable_dict, immutable_list
import torch
import builtins
import types
from ... |
combineCommandLineOptionsDictIntoShellCommand | Write out the compas input parameters into a shell string.
Ensure the Compas executable is first, and not repeated.
Options are non-ordered. | import numpy as np
import sys
import os
import re
import ntpath
from subprocess import call
#### DISCLAIMER: This script uses the `pythonSubmit.py` format
#### that has been replaced by the `runSubmit.py` and
#### `compasConfigDefault.yaml` combo as of v02.25.10.
#### The `pythonSubmit.py` format will eventually beco... | def combineCommandLineOptionsDictIntoShellCommand(commandOptions):
"""
Write out the compas input parameters into a shell string.
Ensure the Compas executable is first, and not repeated.
Options are non-ordered.
"""
shellCommand = commandOptions['compas_executable']
del commandOptions['comp... | 771 | 783 | import numpy as np
import sys
import os
import re
import ntpath
from subprocess import call
#### DISCLAIMER: This script uses the `pythonSubmit.py` format
#### that has been replaced by the `runSubmit.py` and
#### `compasConfigDefault.yaml` combo as of v02.25.10.
#### The `pythonSubmit.py` format will eventually beco... |
thresholded_value_comparison | Compare -2,-1,0,1,2 gene-level thresholded calls. metric can be either
hamming (number of discrepancies in each gene) or manhattan (sum of
'distances' between each gene so a 1 to -1 change is 2). Returns a vector
of each gene's metric. | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 22 17:28:54 2018
@author: galengao
This is the original analysis code as it exists in the environment where it was writen and initially run.
Portions and modifications of this script constitute all other .py scripts in this directory.
"""
import nu... | def thresholded_value_comparison(df_hg38, df_hg19, metric='hamming'):
"""Compare -2,-1,0,1,2 gene-level thresholded calls. metric can be either
hamming (number of discrepancies in each gene) or manhattan (sum of
'distances' between each gene so a 1 to -1 change is 2). Returns a vector
of each gene's me... | 106 | 117 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 22 17:28:54 2018
@author: galengao
This is the original analysis code as it exists in the environment where it was writen and initially run.
Portions and modifications of this script constitute all other .py scripts in this directory.
"""
import nu... |
_DashboardJsonToRawRows | Formats a Dashboard JSON dict as a list of row dicts.
For the dashboard to begin accepting the Telemetry Dashboard JSON format
as per go/telemetry-json, this function chunks a Dashboard JSON literal
into rows and passes the resulting list to _AddTasks.
Args:
dash_json_dict: A dashboard JSON v1.0 dict.
Returns:
A... | # Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""URL endpoint to allow Buildbot slaves to post data to the dashboard."""
import copy
import json
import logging
import math
import re
from google.appengi... | def _DashboardJsonToRawRows(dash_json_dict):
"""Formats a Dashboard JSON dict as a list of row dicts.
For the dashboard to begin accepting the Telemetry Dashboard JSON format
as per go/telemetry-json, this function chunks a Dashboard JSON literal
into rows and passes the resulting list to _AddTasks.
Args:
... | 161 | 231 | # Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""URL endpoint to allow Buildbot slaves to post data to the dashboard."""
import copy
import json
import logging
import math
import re
from google.appengi... |
_AddTasks | Puts tasks on queue for adding data.
Args:
data: A list of dictionaries, each of which represents one point. | # Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""URL endpoint to allow Buildbot slaves to post data to the dashboard."""
import copy
import json
import logging
import math
import re
from google.appengi... | def _AddTasks(data):
"""Puts tasks on queue for adding data.
Args:
data: A list of dictionaries, each of which represents one point.
"""
task_list = []
for data_sublist in _Chunk(data, _TASK_QUEUE_SIZE):
task_list.append(taskqueue.Task(
url='/add_point_queue',
params={'data': json.dum... | 249 | 264 | # Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""URL endpoint to allow Buildbot slaves to post data to the dashboard."""
import copy
import json
import logging
import math
import re
from google.appengi... |
_ValidateRowDict | Checks all fields in the input dictionary.
Args:
row: A dictionary which represents one point.
test_map: A dictionary mapping test paths to last added revision.
Raises:
BadRequestError: The input was not valid. | # Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""URL endpoint to allow Buildbot slaves to post data to the dashboard."""
import copy
import json
import logging
import math
import re
from google.appengi... | def _ValidateRowDict(row, test_map):
"""Checks all fields in the input dictionary.
Args:
row: A dictionary which represents one point.
test_map: A dictionary mapping test paths to last added revision.
Raises:
BadRequestError: The input was not valid.
"""
required_fields = ['master', 'bot', 'test... | 552 | 568 | # Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""URL endpoint to allow Buildbot slaves to post data to the dashboard."""
import copy
import json
import logging
import math
import re
from google.appengi... |
_ValidateRowId | Checks whether the ID for a Row is OK.
Args:
row_dict: A dictionary with new point properties, including "revision".
test_map: A dictionary mapping test paths to the last previously added
revision for each test.
Raises:
BadRequestError: The revision is not acceptable for some reason. | # Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""URL endpoint to allow Buildbot slaves to post data to the dashboard."""
import copy
import json
import logging
import math
import re
from google.appengi... | def _ValidateRowId(row_dict, test_map):
"""Checks whether the ID for a Row is OK.
Args:
row_dict: A dictionary with new point properties, including "revision".
test_map: A dictionary mapping test paths to the last previously added
revision for each test.
Raises:
BadRequestError: The revision... | 612 | 640 | # Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""URL endpoint to allow Buildbot slaves to post data to the dashboard."""
import copy
import json
import logging
import math
import re
from google.appengi... |
_GetSupplementalColumns | Gets a dict of supplemental columns.
If any columns are invalid, a warning is logged and they just aren't included,
but no exception is raised.
Individual rows may specify up to _MAX_NUM_COLUMNS extra data, revision,
and annotation columns. These columns must follow formatting rules for
their type. Invalid columns ar... | # Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""URL endpoint to allow Buildbot slaves to post data to the dashboard."""
import copy
import json
import logging
import math
import re
from google.appengi... | def _GetSupplementalColumns(row):
"""Gets a dict of supplemental columns.
If any columns are invalid, a warning is logged and they just aren't included,
but no exception is raised.
Individual rows may specify up to _MAX_NUM_COLUMNS extra data, revision,
and annotation columns. These columns must follow form... | 753 | 780 | # Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""URL endpoint to allow Buildbot slaves to post data to the dashboard."""
import copy
import json
import logging
import math
import re
from google.appengi... |
convert_k8s_obj_to_json | Builds a JSON K8s object.
If obj is None, return None.
If obj is str, int, long, float, bool, return directly.
If obj is datetime.datetime, datetime.date
convert to string in iso8601 format.
If obj is list, sanitize each element in the list.
If obj is dict, return the dict.
If obj is swagger model, return the prop... | # Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | @staticmethod
def convert_k8s_obj_to_json(k8s_obj):
"""
Builds a JSON K8s object.
If obj is None, return None.
If obj is str, int, long, float, bool, return directly.
If obj is datetime.datetime, datetime.date
convert to string in iso8601 format.
If obj is list, sanitize each elemen... | 132 | 183 | # Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... |
__init__ | Initialize an Offline Connection object.
>>> monascastatsd = MonascaStatsd()
:name: the name for this client. Everything sent by this client
will be prefixed by name
:param host: the host of the MonascaStatsd server.
:param port: the port of the MonascaStatsd server.
:param max_buffer_size: Maximum number of met... | # (C) Copyright 2016 Hewlett Packard Enterprise Development LP
# Copyright 2016 FUJITSU LIMITED
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#... | def __init__(self, host='localhost', port=8125, max_buffer_size=50):
"""Initialize an Offline Connection object.
>>> monascastatsd = MonascaStatsd()
:name: the name for this client. Everything sent by this client
will be prefixed by name
:param host: the host of the Mo... | 111 | 126 | # (C) Copyright 2016 Hewlett Packard Enterprise Development LP
# Copyright 2016 FUJITSU LIMITED
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#... |
value_iteration | Solves the shortest path problem using value iteration
:input town_map env : The town_map environment in which we seek to
find the shortest path.
:input float gamma : The discount factor.
:input float epsilon : accuracy of the value iteration procedure.
:return numpy.ar... | import numpy as np
import matplotlib.pyplot as plt
import time
from IPython import display
# Implemented methods
methods = ['DynProg', 'ValIter'];
# Some colours
LIGHT_RED = '#FFC4CC';
LIGHT_GREEN = '#95FD99';
BLACK = '#000000';
WHITE = '#FFFFFF';
LIGHT_PURPLE = '#E8D0FF';
LIGHT_ORANGE = '#FAE0C3';
... | def value_iteration(env, gamma, epsilon):
""" Solves the shortest path problem using value iteration
:input town_map env : The town_map environment in which we seek to
find the shortest path.
:input float gamma : The discount factor.
:inpu... | 221 | 275 | import numpy as np
import matplotlib.pyplot as plt
import time
from IPython import display
# Implemented methods
methods = ['DynProg', 'ValIter'];
# Some colours
LIGHT_RED = '#FFC4CC';
LIGHT_GREEN = '#95FD99';
BLACK = '#000000';
WHITE = '#FFFFFF';
LIGHT_PURPLE = '#E8D0FF';
LIGHT_ORANGE = '#FAE0C3';
... |
__move | Makes a step in the town_map, given a current position and an action.
If the action STAY or an inadmissible action is used, the robber stays in place.
:return integer next_cell corresponding to position (x,y) x (x,y) on the town_map that agent transitions to. | import numpy as np
import matplotlib.pyplot as plt
import time
from IPython import display
# Implemented methods
methods = ['DynProg', 'ValIter'];
# Some colours
LIGHT_RED = '#FFC4CC';
LIGHT_GREEN = '#95FD99';
BLACK = '#000000';
WHITE = '#FFFFFF';
LIGHT_PURPLE = '#E8D0FF';
LIGHT_ORANGE = '#FAE0C3';
... | def __move(self, state, action):
""" Makes a step in the town_map, given a current position and an action.
If the action STAY or an inadmissible action is used, the robber stays in place.
:return integer next_cell corresponding to position (x,y) x (x,y) on the town_map that agent tr... | 80 | 104 | import numpy as np
import matplotlib.pyplot as plt
import time
from IPython import display
# Implemented methods
methods = ['DynProg', 'ValIter'];
# Some colours
LIGHT_RED = '#FFC4CC';
LIGHT_GREEN = '#95FD99';
BLACK = '#000000';
WHITE = '#FFFFFF';
LIGHT_PURPLE = '#E8D0FF';
LIGHT_ORANGE = '#FAE0C3';
... |
__transitions | Computes the transition probabilities for every state action pair.
:return numpy.tensor transition probabilities: tensor of transition
probabilities of dimension S*S*A | import numpy as np
import matplotlib.pyplot as plt
import time
from IPython import display
# Implemented methods
methods = ['DynProg', 'ValIter'];
# Some colours
LIGHT_RED = '#FFC4CC';
LIGHT_GREEN = '#95FD99';
BLACK = '#000000';
WHITE = '#FFFFFF';
LIGHT_PURPLE = '#E8D0FF';
LIGHT_ORANGE = '#FAE0C3';
... | def __transitions(self):
""" Computes the transition probabilities for every state action pair.
:return numpy.tensor transition probabilities: tensor of transition
probabilities of dimension S*S*A
"""
# Initialize the transition probailities tensor (S,S,A)
dim... | 120 | 145 | import numpy as np
import matplotlib.pyplot as plt
import time
from IPython import display
# Implemented methods
methods = ['DynProg', 'ValIter'];
# Some colours
LIGHT_RED = '#FFC4CC';
LIGHT_GREEN = '#95FD99';
BLACK = '#000000';
WHITE = '#FFFFFF';
LIGHT_PURPLE = '#E8D0FF';
LIGHT_ORANGE = '#FAE0C3';
... |
_verify_local_backends | Return the local backends in `SDK_STANDARD_BACKENDS` that are
effectively available (as some of them might depend on the presence
of an optional dependency or on the existence of a binary).
Returns:
dict[str:BaseBackend]: a dict of the local backends instances for
the backends that could be instantiated, k... | # -*- coding: utf-8 -*-
# Copyright 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
# pylint: disable=invalid-name, bad-continuation
"""Provider for local backends."""
import logging
from qiskit._qiskiterror... | @classmethod
def _verify_local_backends(cls):
"""
Return the local backends in `SDK_STANDARD_BACKENDS` that are
effectively available (as some of them might depend on the presence
of an optional dependency or on the existence of a binary).
Returns:
dict[str:B... | 73 | 94 | # -*- coding: utf-8 -*-
# Copyright 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
# pylint: disable=invalid-name, bad-continuation
"""Provider for local backends."""
import logging
from qiskit._qiskiterror... |
draw_collection | Draw a collection of lines.
Parameters
----------
collection: list of compas.geometry.Line
A collection of ``Line`` objects.
names : list of str, optional
Individual names for the lines.
colors : color or list of color, optional
A color specification for the lines as a single color or a list of individual ... | from __future__ import print_function
from __future__ import absolute_import
from __future__ import division
try:
basestring
except NameError:
basestring = str
import compas_rhino
from compas.utilities import iterable_like
from compas_rhino.artists._primitiveartist import PrimitiveArtist
__all__ = ['LineArt... | @staticmethod
def draw_collection(collection, names=None, colors=None, layer=None, clear=False, add_to_group=False, group_name=None):
"""Draw a collection of lines.
Parameters
----------
collection: list of compas.geometry.Line
A collection of ``Line`` objects.
... | 48 | 98 | from __future__ import print_function
from __future__ import absolute_import
from __future__ import division
try:
basestring
except NameError:
basestring = str
import compas_rhino
from compas.utilities import iterable_like
from compas_rhino.artists._primitiveartist import PrimitiveArtist
__all__ = ['LineArt... |
get_cython_func_and_vals | Find the appropriate cython function, casting if necessary.
Parameters
----------
values : np.ndarray
is_numeric : bool
Returns
-------
func : callable
values : np.ndarray | """
Provide classes to perform the groupby aggregate operations.
These are not exposed to the user and provide implementations of the grouping
operations, primarily in cython. These classes (BaseGrouper and BinGrouper)
are contained *in* the SeriesGroupBy and DataFrameGroupBy objects.
"""
from __future__ import annota... | def get_cython_func_and_vals(self, values: np.ndarray, is_numeric: bool):
"""
Find the appropriate cython function, casting if necessary.
Parameters
----------
values : np.ndarray
is_numeric : bool
Returns
-------
func : callable
valu... | 172 | 208 | """
Provide classes to perform the groupby aggregate operations.
These are not exposed to the user and provide implementations of the grouping
operations, primarily in cython. These classes (BaseGrouper and BinGrouper)
are contained *in* the SeriesGroupBy and DataFrameGroupBy objects.
"""
from __future__ import annota... |
_get_result_dtype | Get the desired dtype of a result based on the
input dtype and how it was computed.
Parameters
----------
dtype : np.dtype or ExtensionDtype
Input dtype.
Returns
-------
np.dtype or ExtensionDtype
The desired dtype of the result. | """
Provide classes to perform the groupby aggregate operations.
These are not exposed to the user and provide implementations of the grouping
operations, primarily in cython. These classes (BaseGrouper and BinGrouper)
are contained *in* the SeriesGroupBy and DataFrameGroupBy objects.
"""
from __future__ import annota... | def _get_result_dtype(self, dtype: DtypeObj) -> DtypeObj:
"""
Get the desired dtype of a result based on the
input dtype and how it was computed.
Parameters
----------
dtype : np.dtype or ExtensionDtype
Input dtype.
Returns
-------
... | 285 | 314 | """
Provide classes to perform the groupby aggregate operations.
These are not exposed to the user and provide implementations of the grouping
operations, primarily in cython. These classes (BaseGrouper and BinGrouper)
are contained *in* the SeriesGroupBy and DataFrameGroupBy objects.
"""
from __future__ import annota... |
agg_series | Parameters
----------
obj : Series
func : function taking a Series and returning a scalar-like
preserve_dtype : bool
Whether the aggregation is known to be dtype-preserving.
Returns
-------
np.ndarray or ExtensionArray | """
Provide classes to perform the groupby aggregate operations.
These are not exposed to the user and provide implementations of the grouping
operations, primarily in cython. These classes (BaseGrouper and BinGrouper)
are contained *in* the SeriesGroupBy and DataFrameGroupBy objects.
"""
from __future__ import annota... | @final
def agg_series(
self, obj: Series, func: Callable, preserve_dtype: bool = False
) -> ArrayLike:
"""
Parameters
----------
obj : Series
func : function taking a Series and returning a scalar-like
preserve_dtype : bool
Whether the aggr... | 947 | 987 | """
Provide classes to perform the groupby aggregate operations.
These are not exposed to the user and provide implementations of the grouping
operations, primarily in cython. These classes (BaseGrouper and BinGrouper)
are contained *in* the SeriesGroupBy and DataFrameGroupBy objects.
"""
from __future__ import annota... |
scalar_mul | Multiplies a scalar times a `Tensor` or `IndexedSlices` object.
Intended for use in gradient code which might deal with `IndexedSlices`
objects, which are easy to multiply by a scalar but more expensive to
multiply with arbitrary tensors.
Args:
scalar: A 0-D scalar `Tensor`. Must have known shape.
x: A `Tensor` o... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export(v1=["math.scalar_mul", "scalar_mul"])
def scalar_mul(scalar, x, name=None):
"""Multiplies a scalar times a `Tensor` or `IndexedSlices` object.
Intended for use in gradient code which might deal with `IndexedSlices`
objects, which are easy to multiply by a scalar but more expensive to
multiply with a... | 314 | 343 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
round | Rounds the values of a tensor to the nearest integer, element-wise.
Rounds half to even. Also known as bankers rounding. If you want to round
according to the current system rounding mode use tf::cint.
For example:
```python
x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])
tf.round(x) # [ 1.0, 2.0, 2.0, 2.0, -4.0 ]
```
... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export("math.round", "round")
@dispatch.add_dispatch_support
def round(x, name=None): # pylint: disable=redefined-builtin
"""Rounds the values of a tensor to the nearest integer, element-wise.
Rounds half to even. Also known as bankers rounding. If you want to round
according to the current system rounding... | 531 | 556 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
_OverrideBinaryOperatorHelper | Register operators with different tensor and scalar versions.
If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,
sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.
Args:
func: the operator
op_name: name of the operator being overridden
clazz_object: class to override for. Either `... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | def _OverrideBinaryOperatorHelper(func, op_name, clazz_object=ops.Tensor):
"""Register operators with different tensor and scalar versions.
If `clazz_object` is `SparseTensor`, assumes `func` takes `(sp_indices,
sp_values, sp_shape, dense)` and outputs `(new_sp_values)`.
Args:
func: the operator
op_na... | 798 | 861 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
reduce_sum_v1 | Computes the sum of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keepdims` is true, the reduced dimensions
are retained with length 1.
If `axis` is None, all dimensio... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export(v1=["math.reduce_sum", "reduce_sum"])
@deprecation.deprecated_args(
None, "keep_dims is deprecated, use keepdims instead", "keep_dims")
def reduce_sum_v1(input_tensor,
axis=None,
keepdims=None,
name=None,
reduction_indices=None,
... | 1,236 | 1,288 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
count_nonzero | Computes number of nonzero elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keepdims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export(v1=["math.count_nonzero", "count_nonzero"])
@deprecation.deprecated_args(
None, "keep_dims is deprecated, use keepdims instead", "keep_dims")
@deprecation.deprecated_args(
None, "reduction_indices is deprecated, use axis instead", "axis")
def count_nonzero(input_tensor,
axis=None,
... | 1,339 | 1,407 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
count_nonzero_v2 | Computes number of nonzero elements across dimensions of a tensor.
Reduces `input` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keepdims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, all d... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export("math.count_nonzero", v1=[])
def count_nonzero_v2(input, # pylint: disable=redefined-builtin
axis=None,
keepdims=None,
dtype=dtypes.int64,
name=None):
"""Computes number of nonzero elements across dimensions of a tensor.
... | 1,410 | 1,475 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
reduce_prod_v1 | Computes the product of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keepdims` is true, the reduced dimensions
are retained with length 1.
If `axis` is None, all dime... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export(v1=["math.reduce_prod", "reduce_prod"])
@deprecation.deprecated_args(
None, "keep_dims is deprecated, use keepdims instead", "keep_dims")
def reduce_prod_v1(input_tensor,
axis=None,
keepdims=None,
name=None,
reduction_indices=Non... | 1,729 | 1,769 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
reduce_min_v1 | Computes the minimum of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keepdims` is true, the reduced dimensions
are retained with length 1.
If `axis` is None, all dime... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export(v1=["math.reduce_min", "reduce_min"])
@deprecation.deprecated_args(
None, "keep_dims is deprecated, use keepdims instead", "keep_dims")
def reduce_min_v1(input_tensor,
axis=None,
keepdims=None,
name=None,
reduction_indices=None,
... | 1,772 | 1,812 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
reduce_max_v1 | Computes the maximum of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keepdims` is true, the reduced dimensions
are retained with length 1.
If `axis` is None, all dime... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export(v1=["math.reduce_max", "reduce_max"])
@deprecation.deprecated_args(
None, "keep_dims is deprecated, use keepdims instead", "keep_dims")
def reduce_max_v1(input_tensor,
axis=None,
keepdims=None,
name=None,
reduction_indices=None,
... | 1,851 | 1,891 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
reduce_all_v1 | Computes the "logical and" of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keepdims` is true, the reduced dimensions
are retained with length 1.
If `axis` is None, al... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export(v1=["math.reduce_all", "reduce_all"])
@deprecation.deprecated_args(
None, "keep_dims is deprecated, use keepdims instead", "keep_dims")
def reduce_all_v1(input_tensor,
axis=None,
keepdims=None,
name=None,
reduction_indices=None,
... | 1,930 | 1,979 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
reduce_any_v1 | Computes the "logical or" of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keepdims` is true, the reduced dimensions
are retained with length 1.
If `axis` is None, all... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export(v1=["math.reduce_any", "reduce_any"])
@deprecation.deprecated_args(
None, "keep_dims is deprecated, use keepdims instead", "keep_dims")
def reduce_any_v1(input_tensor,
axis=None,
keepdims=None,
name=None,
reduction_indices=None,
... | 2,027 | 2,076 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
reduce_logsumexp_v1 | Computes log(sum(exp(elements across dimensions of a tensor))).
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keepdims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, a... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export(v1=["math.reduce_logsumexp", "reduce_logsumexp"])
@deprecation.deprecated_args(
None, "keep_dims is deprecated, use keepdims instead", "keep_dims")
def reduce_logsumexp_v1(input_tensor,
axis=None,
keepdims=None,
name=None,
... | 2,124 | 2,175 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
reduce_logsumexp | Computes log(sum(exp(elements across dimensions of a tensor))).
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keepdims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, a... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export("math.reduce_logsumexp", "reduce_logsumexp", v1=[])
def reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):
"""Computes log(sum(exp(elements across dimensions of a tensor))).
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keepdims` is true, the rank of the tenso... | 2,178 | 2,235 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
_as_indexed_slices | Convert 'x' to IndexedSlices.
Convert a dense Tensor to a block-sparse IndexedSlices.
Args:
x: Either a Tensor object, or an IndexedSlices object.
optimize: if true, attempt to optimize the conversion of 'x'.
Returns:
An IndexedSlices object.
Raises:
TypeError: If 'x' is not a Tensor or an IndexedSlices obj... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | def _as_indexed_slices(x, optimize=True):
"""Convert 'x' to IndexedSlices.
Convert a dense Tensor to a block-sparse IndexedSlices.
Args:
x: Either a Tensor object, or an IndexedSlices object.
optimize: if true, attempt to optimize the conversion of 'x'.
Returns:
An IndexedSlices object.
Raises... | 2,583 | 2,604 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
_as_indexed_slices_list | Convert all elements of 'inputs' to IndexedSlices.
Additionally, homogenize the types of all the indices to
either int32 or int64.
Args:
inputs: List containing either Tensor or IndexedSlices objects.
optimize: if true, attempt to optimize the conversion of each input.
Returns:
A list of IndexedSlices objects.... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | def _as_indexed_slices_list(inputs, optimize=True):
"""Convert all elements of 'inputs' to IndexedSlices.
Additionally, homogenize the types of all the indices to
either int32 or int64.
Args:
inputs: List containing either Tensor or IndexedSlices objects.
optimize: if true, attempt to optimize the con... | 2,607 | 2,639 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
add_n | Adds all input tensors element-wise.
Converts `IndexedSlices` objects into dense tensors prior to adding.
Args:
inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape
and type.
name: A name for the operation (optional).
Returns:
A `Tensor` of same shape and type as the elements of `inp... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export("math.add_n", "add_n")
@dispatch.add_dispatch_support
def add_n(inputs, name=None):
"""Adds all input tensors element-wise.
Converts `IndexedSlices` objects into dense tensors prior to adding.
Args:
inputs: A list of `Tensor` or `IndexedSlices` objects, each with same shape
and type.
na... | 2,642 | 2,677 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
accumulate_n | Returns the element-wise sum of a list of tensors.
Optionally, pass `shape` and `tensor_dtype` for shape and type checking,
otherwise, these are inferred.
`tf.math.accumulate_n` performs the same operation as `tf.add_n`, but does not
wait for all of its inputs to be ready before beginning to sum. This can
save memory... | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | @tf_export("math.accumulate_n", v1=["math.accumulate_n", "accumulate_n"])
@deprecation.deprecated_endpoints("accumulate_n")
def accumulate_n(inputs, shape=None, tensor_dtype=None, name=None):
"""Returns the element-wise sum of a list of tensors.
Optionally, pass `shape` and `tensor_dtype` for shape and type checki... | 2,680 | 2,757 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
reduced_shape | Helper function for reduction ops.
Args:
input_shape: 1-D Tensor, the shape of the Tensor being reduced.
axes: 1-D Tensor, the reduction axes.
Returns:
A 1-D Tensor, the output shape as if keepdims were set to True. | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | def reduced_shape(input_shape, axes):
"""Helper function for reduction ops.
Args:
input_shape: 1-D Tensor, the shape of the Tensor being reduced.
axes: 1-D Tensor, the reduction axes.
Returns:
A 1-D Tensor, the output shape as if keepdims were set to True.
"""
# Example:
# cast needed for Spars... | 3,053 | 3,084 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... |
read_zfile | Read the z-file and return the content as a string
Z-files are raw data compressed with zlib used internally by joblib
for persistence. Backward compatibility is not guaranteed. Do not
use for external purposes. | """
Utilities for fast persistence of big data, with optional compression.
"""
# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
# Copyright (c) 2009 Gael Varoquaux
# License: BSD Style, 3 clauses.
import pickle
import traceback
import os
import zlib
import warnings
from io import BytesIO
from ._co... | def read_zfile(file_handle):
"""Read the z-file and return the content as a string
Z-files are raw data compressed with zlib used internally by joblib
for persistence. Backward compatibility is not guaranteed. Do not
use for external purposes.
"""
file_handle.seek(0)
assert _read_magic(file... | 61 | 93 | """
Utilities for fast persistence of big data, with optional compression.
"""
# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
# Copyright (c) 2009 Gael Varoquaux
# License: BSD Style, 3 clauses.
import pickle
import traceback
import os
import zlib
import warnings
from io import BytesIO
from ._co... |
write_zfile | Write the data in the given file as a Z-file.
Z-files are raw data compressed with zlib used internally by joblib
for persistence. Backward compatibility is not guarantied. Do not
use for external purposes. | """
Utilities for fast persistence of big data, with optional compression.
"""
# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
# Copyright (c) 2009 Gael Varoquaux
# License: BSD Style, 3 clauses.
import pickle
import traceback
import os
import zlib
import warnings
from io import BytesIO
from ._co... | def write_zfile(file_handle, data, compress=1):
"""Write the data in the given file as a Z-file.
Z-files are raw data compressed with zlib used internally by joblib
for persistence. Backward compatibility is not guarantied. Do not
use for external purposes.
"""
file_handle.write(_ZFILE_PREFIX)
... | 96 | 107 | """
Utilities for fast persistence of big data, with optional compression.
"""
# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
# Copyright (c) 2009 Gael Varoquaux
# License: BSD Style, 3 clauses.
import pickle
import traceback
import os
import zlib
import warnings
from io import BytesIO
from ._co... |
dump | Fast persistence of an arbitrary Python object into one or multiple
files, with dedicated storage for numpy arrays.
Parameters
-----------
value: any Python object
The object to store to disk
filename: string
The name of the file in which it is to be stored
compress: integer for 0 to 9, optional
Optional c... | """
Utilities for fast persistence of big data, with optional compression.
"""
# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
# Copyright (c) 2009 Gael Varoquaux
# License: BSD Style, 3 clauses.
import pickle
import traceback
import os
import zlib
import warnings
from io import BytesIO
from ._co... | def dump(value, filename, compress=0, cache_size=100, protocol=None):
"""Fast persistence of an arbitrary Python object into one or multiple
files, with dedicated storage for numpy arrays.
Parameters
-----------
value: any Python object
The object to store to disk
filename: string
... | 348 | 409 | """
Utilities for fast persistence of big data, with optional compression.
"""
# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
# Copyright (c) 2009 Gael Varoquaux
# License: BSD Style, 3 clauses.
import pickle
import traceback
import os
import zlib
import warnings
from io import BytesIO
from ._co... |
load_build | This method is called to set the state of a newly created
object.
We capture it to replace our place-holder objects,
NDArrayWrapper, by the array we are interested in. We
replace them directly in the stack of pickler. | """
Utilities for fast persistence of big data, with optional compression.
"""
# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
# Copyright (c) 2009 Gael Varoquaux
# License: BSD Style, 3 clauses.
import pickle
import traceback
import os
import zlib
import warnings
from io import BytesIO
from ._co... | def load_build(self):
""" This method is called to set the state of a newly created
object.
We capture it to replace our place-holder objects,
NDArrayWrapper, by the array we are interested in. We
replace them directly in the stack of pickler.
"""
... | 308 | 323 | """
Utilities for fast persistence of big data, with optional compression.
"""
# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
# Copyright (c) 2009 Gael Varoquaux
# License: BSD Style, 3 clauses.
import pickle
import traceback
import os
import zlib
import warnings
from io import BytesIO
from ._co... |
filter_by_size | [deprecated] Filter indices based on their size.
Use `FairseqDataset::filter_indices_by_size` instead.
Args:
indices (List[int]): ordered list of dataset indices
dataset (FairseqDataset): fairseq dataset instance
max_positions (tuple): filter elements larger than this size.
Comparisons are done com... | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
try:
from collections.abc import Iterable
except ImportError:
from collections import Iterable
import contextlib
import itertools
impo... | def filter_by_size(indices, dataset, max_positions, raise_exception=False):
"""
[deprecated] Filter indices based on their size.
Use `FairseqDataset::filter_indices_by_size` instead.
Args:
indices (List[int]): ordered list of dataset indices
dataset (FairseqDataset): fairseq dataset ins... | 193 | 243 | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
try:
from collections.abc import Iterable
except ImportError:
from collections import Iterable
import contextlib
import itertools
impo... |
filter_paired_dataset_indices_by_size | Filter a list of sample indices. Remove those that are longer
than specified in max_sizes.
Args:
indices (np.array): original array of sample indices
max_sizes (int or list[int] or tuple[int]): max sample size,
can be defined separately for src and tgt (then list or tuple)
Returns:
np.array: f... | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
try:
from collections.abc import Iterable
except ImportError:
from collections import Iterable
import contextlib
import itertools
impo... | def filter_paired_dataset_indices_by_size(src_sizes, tgt_sizes, indices, max_sizes):
"""Filter a list of sample indices. Remove those that are longer
than specified in max_sizes.
Args:
indices (np.array): original array of sample indices
max_sizes (int or list[int] or tuple[int]): max s... | 246 | 279 | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
try:
from collections.abc import Iterable
except ImportError:
from collections import Iterable
import contextlib
import itertools
impo... |
batch_by_size | Yield mini-batches of indices bucketed by size. Batches may contain
sequences of different lengths.
Args:
indices (List[int]): ordered list of dataset indices
num_tokens_fn (callable): function that returns the number of tokens at
a given index
num_tokens_vec (List[int], optional): precomputed vect... | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
try:
from collections.abc import Iterable
except ImportError:
from collections import Iterable
import contextlib
import itertools
impo... | def batch_by_size(
indices,
num_tokens_fn,
num_tokens_vec=None,
max_tokens=None,
max_sentences=None,
required_batch_size_multiple=1,
fixed_shapes=None,
):
"""
Yield mini-batches of indices bucketed by size. Batches may contain
sequences of different lengths.
Args:
in... | 282 | 365 | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
try:
from collections.abc import Iterable
except ImportError:
from collections import Iterable
import contextlib
import itertools
impo... |
main | Process command line arguments and invoke bot.
If args is an empty list, sys.argv is used.
@param args: command line arguments
@type args: str | #!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Script to upload the mappings of Freebase to Wikidata.
Can be easily adapted to upload other String identifiers as well
This bot needs the dump from
https://developers.google.com/freebase/data#freebase-wikidata-mappings
The script takes a single parameter:
-filename: th... | def main(*args):
"""
Process command line arguments and invoke bot.
If args is an empty list, sys.argv is used.
@param args: command line arguments
@type args: str
"""
filename = 'fb2w.nt.gz' # Default filename
for arg in pywikibot.handle_args(args):
if arg.startswith('-filena... | 107 | 121 | #!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Script to upload the mappings of Freebase to Wikidata.
Can be easily adapted to upload other String identifiers as well
This bot needs the dump from
https://developers.google.com/freebase/data#freebase-wikidata-mappings
The script takes a single parameter:
-filename: th... |
run | On purpose this doesn't call the ObjectDescription version, but is based on it.
Each alias signature may expand into multiple real signatures (an overload set).
The code is therefore based on the ObjectDescription version. | """
sphinx.domains.cpp
~~~~~~~~~~~~~~~~~~
The C++ language domain.
:copyright: Copyright 2007-2020 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
import re
from typing import (
Any, Callable, Dict, Generator, Iterator, List, Tuple, Type, TypeVar, Union
)
from do... | def run(self) -> List[Node]:
"""
On purpose this doesn't call the ObjectDescription version, but is based on it.
Each alias signature may expand into multiple real signatures (an overload set).
The code is therefore based on the ObjectDescription version.
"""
if ':' i... | 6,818 | 6,847 | """
sphinx.domains.cpp
~~~~~~~~~~~~~~~~~~
The C++ language domain.
:copyright: Copyright 2007-2020 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
import re
from typing import (
Any, Callable, Dict, Generator, Iterator, List, Tuple, Type, TypeVar, Union
)
from do... |
get | Get an existing WebAppSitePushSettingsSlot resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOption... | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union
from ... import _utilities, _tables
from... | @staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None) -> 'WebAppSitePushSettingsSlot':
"""
Get an existing WebAppSitePushSettingsSlot resource's state with the given name, id, and optional extra
properties ... | 90 | 114 | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union
from ... import _utilities, _tables
from... |
on_help | Bring up the Kiessig fringe calculator Documentation whenever
the HELP button is clicked.
Calls DocumentationWindow with the path of the location within the
documentation tree (after /doc/ ....". Note that when using old
versions of Wx (before 2.9) and thus not the release version of
installers... | """
This software was developed by the University of Tennessee as part of the
Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
project funded by the US National Science Foundation.
See the license text in license.txt
copyright 2008, 2009, University of Tennessee
"""
import wx
import sys
from sas.... | def on_help(self, event):
"""
Bring up the Kiessig fringe calculator Documentation whenever
the HELP button is clicked.
Calls DocumentationWindow with the path of the location within the
documentation tree (after /doc/ ....". Note that when using old
versions of Wx (... | 161 | 177 | """
This software was developed by the University of Tennessee as part of the
Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
project funded by the US National Science Foundation.
See the license text in license.txt
copyright 2008, 2009, University of Tennessee
"""
import wx
import sys
from sas.... |
blend | Blend image1 and image2 using 'factor'.
Factor can be above 0.0. A value of 0.0 means only image1 is used.
A value of 1.0 means only image2 is used. A value between 0.0 and
1.0 means we linearly interpolate the pixel values between the two
images. A value greater than 1.0 "extrapolates" the difference
between the t... | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | def blend(image1, image2, factor):
"""Blend image1 and image2 using 'factor'.
Factor can be above 0.0. A value of 0.0 means only image1 is used.
A value of 1.0 means only image2 is used. A value between 0.0 and
1.0 means we linearly interpolate the pixel values between the two
images. A value greater than... | 150 | 190 | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... |
rotate | Rotates the image by degrees either clockwise or counterclockwise.
Args:
image: An image Tensor of type uint8.
degrees: Float, a scalar angle in degrees to rotate all images by. If
degrees is positive the image will be rotated clockwise otherwise it will
be rotated counterclockwise.
replace: A one or thr... | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | def rotate(image, degrees, replace):
"""Rotates the image by degrees either clockwise or counterclockwise.
Args:
image: An image Tensor of type uint8.
degrees: Float, a scalar angle in degrees to rotate all images by. If
degrees is positive the image will be rotated clockwise otherwise it will
... | 295 | 317 | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... |
_clip_bbox | Clip bounding box coordinates between 0 and 1.
Args:
min_y: Normalized bbox coordinate of type float between 0 and 1.
min_x: Normalized bbox coordinate of type float between 0 and 1.
max_y: Normalized bbox coordinate of type float between 0 and 1.
max_x: Normalized bbox coordinate of type float between 0 and 1... | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | def _clip_bbox(min_y, min_x, max_y, max_x):
"""Clip bounding box coordinates between 0 and 1.
Args:
min_y: Normalized bbox coordinate of type float between 0 and 1.
min_x: Normalized bbox coordinate of type float between 0 and 1.
max_y: Normalized bbox coordinate of type float between 0 and 1.
max_... | 435 | 451 | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... |
_rotate_bbox | Rotates the bbox coordinated by degrees.
Args:
bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)
of type float that represents the normalized coordinates between 0 and 1.
image_height: Int, height of the image.
image_width: Int, height of the image.
degrees: Float, a scalar angle in degrees ... | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | def _rotate_bbox(bbox, image_height, image_width, degrees):
"""Rotates the bbox coordinated by degrees.
Args:
bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)
of type float that represents the normalized coordinates between 0 and 1.
image_height: Int, height of the image.
image_wi... | 785 | 835 | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... |
_shift_bbox | Shifts the bbox coordinates by pixels.
Args:
bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)
of type float that represents the normalized coordinates between 0 and 1.
image_height: Int, height of the image.
image_width: Int, width of the image.
pixels: An int. How many pixels to shift the ... | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | def _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):
"""Shifts the bbox coordinates by pixels.
Args:
bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)
of type float that represents the normalized coordinates between 0 and 1.
image_height: Int, height of the image... | 881 | 919 | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... |
_shear_bbox | Shifts the bbox according to how the image was sheared.
Args:
bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)
of type float that represents the normalized coordinates between 0 and 1.
image_height: Int, height of the image.
image_width: Int, height of the image.
level: Float. How much to s... | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | def _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):
"""Shifts the bbox according to how the image was sheared.
Args:
bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)
of type float that represents the normalized coordinates between 0 and 1.
image_height: Int, hei... | 978 | 1,025 | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... |
distort_image_with_autoaugment | Applies the AutoAugment policy to `image` and `bboxes`.
Args:
image: `Tensor` of shape [height, width, 3] representing an image.
bboxes: `Tensor` of shape [N, 4] representing ground truth boxes that are
normalized between [0, 1].
augmentation_name: The name of the AutoAugment policy to use. The available
... | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | @tf.autograph.experimental.do_not_convert
def distort_image_with_autoaugment(image,
bboxes,
augmentation_name):
"""Applies the AutoAugment policy to `image` and `bboxes`.
Args:
image: `Tensor` of shape [height, width, 3] representing an imag... | 1,591 | 1,629 | # Copyright 2020 Google Research. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... |
get_hgmo_archive | An archiver for hg.mozilla.org related requests. Uses relengapi.blueprints.archiver.get_archive
:param repo: the repo location off of hg.mozilla.org/
:param rev: the rev associated with the repo
:param subdir: optional subdir path to only archive a portion of the repo
:param suffix: the archive extension type. default... | # This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import logging
import datetime
import sqlalchemy as sa
from random import randint
from flask import Blueprint
from f... | @bp.route('/hgmo/<path:repo>/<rev>')
@api.apimethod(None, unicode, unicode, unicode, unicode, unicode, status_code=302)
def get_hgmo_archive(repo, rev, subdir=None, suffix='tar.gz', preferred_region=None):
"""
An archiver for hg.mozilla.org related requests. Uses relengapi.blueprints.archiver.get_archive
:... | 124 | 147 | # This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import logging
import datetime
import sqlalchemy as sa
from random import randint
from flask import Blueprint
from f... |
is_absolute_uri | Returns True if the parsed result is an "absolute URI".
We define an "absolute URI" as containing at mimimum a **scheme** and an
**host** (a.k.a., an authority).
It must contain SH according to the nomenclature defined in this proposal:
https://gist.github.com/andrewdotn/eebeaa60d48c3c0f6f9fc75f0ede8d03#proposal
Exa... | """
Get absolute URLs for static assets.
"""
from urllib.parse import ParseResult, urlparse, urlunparse
from django import template
from django.templatetags.static import StaticNode
from django.urls import reverse
register = template.Library()
class AbstaticNode(StaticNode):
"""
{% abstatic %} is like Djan... | def is_absolute_uri(url: ParseResult) -> bool:
"""
Returns True if the parsed result is an "absolute URI".
We define an "absolute URI" as containing at mimimum a **scheme** and an
**host** (a.k.a., an authority).
It must contain SH according to the nomenclature defined in this proposal:
https:... | 34 | 65 | """
Get absolute URLs for static assets.
"""
from urllib.parse import ParseResult, urlparse, urlunparse
from django import template
from django.templatetags.static import StaticNode
from django.urls import reverse
register = template.Library()
class AbstaticNode(StaticNode):
"""
{% abstatic %} is like Djan... |
test_can_add_gates_into_free_space | The scheduler does some time bookkeeping to know when qubits are free to be
scheduled. Make sure this works for qubits that are used in the future. This was
a bug, uncovered by this example:
q0 = - - - - |X|
q1 = |X| |u2| |X|
In ALAP scheduling, the next operation on qubit 0 would be added at t=0 rather
than i... | # -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modif... | def test_can_add_gates_into_free_space(self):
"""The scheduler does some time bookkeeping to know when qubits are free to be
scheduled. Make sure this works for qubits that are used in the future. This was
a bug, uncovered by this example:
q0 = - - - - |X|
q1 = |X| |u... | 221 | 246 | # -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modif... |
default_data_collator | Very simple data collator that simply collates batches of dict-like objects and performs special handling for
potential keys named:
- ``label``: handles a single value (int or float) per object
- ``label_ids``: handles a list of values per object
Does not do any additional preprocessing: property names of the... | # Copyright 2020 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicabl... | def default_data_collator(features: List[InputDataClass]) -> Dict[str, torch.Tensor]:
"""
Very simple data collator that simply collates batches of dict-like objects and performs special handling for
potential keys named:
- ``label``: handles a single value (int or float) per object
- ``lab... | 38 | 83 | # Copyright 2020 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicabl... |
_search_table | Call the search service endpoint and return matching results
Search service logic defined here:
https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/table.py
:return: a json output containing search results array as 'results' | import logging
import json
from http import HTTPStatus
from typing import Any, Dict # noqa: F401
from flask import Response, jsonify, make_response, request
from flask import current_app as app
from flask.blueprints import Blueprint
from amundsen_application.log.action_log import action_logging
from amundsen_appli... | @action_logging
def _search_table(*, search_term: str, page_index: int, filters: Dict, search_type: str) -> Dict[str, Any]:
"""
Call the search service endpoint and return matching results
Search service logic defined here:
https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/tab... | 56 | 108 | import logging
import json
from http import HTTPStatus
from typing import Any, Dict # noqa: F401
from flask import Response, jsonify, make_response, request
from flask import current_app as app
from flask.blueprints import Blueprint
from amundsen_application.log.action_log import action_logging
from amundsen_appli... |
_search_user | Call the search service endpoint and return matching results
Search service logic defined here:
https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/user.py
:return: a json output containing search results array as 'results' | import logging
import json
from http import HTTPStatus
from typing import Any, Dict # noqa: F401
from flask import Response, jsonify, make_response, request
from flask import current_app as app
from flask.blueprints import Blueprint
from amundsen_application.log.action_log import action_logging
from amundsen_appli... | @action_logging
def _search_user(*, search_term: str, page_index: int, search_type: str) -> Dict[str, Any]:
"""
Call the search service endpoint and return matching results
Search service logic defined here:
https://github.com/lyft/amundsensearchlibrary/blob/master/search_service/api/user.py
:retur... | 131 | 184 | import logging
import json
from http import HTTPStatus
from typing import Any, Dict # noqa: F401
from flask import Response, jsonify, make_response, request
from flask import current_app as app
from flask.blueprints import Blueprint
from amundsen_application.log.action_log import action_logging
from amundsen_appli... |
start | Start the background coroutine to balance the tasks on the cluster.
Idempotent.
The scheduler argument is ignored. It is merely required to satisify the
plugin interface. Since this class is simultaneouly an extension, the
scheudler instance is already registered during initialization | from __future__ import annotations
import asyncio
import logging
from collections import defaultdict, deque
from math import log2
from time import time
from typing import Container
from tlz import topk
from tornado.ioloop import PeriodicCallback
import dask
from dask.utils import parse_timedelta
from .comm.addressi... | async def start(self, scheduler=None):
"""Start the background coroutine to balance the tasks on the cluster.
Idempotent.
The scheduler argument is ignored. It is merely required to satisify the
plugin interface. Since this class is simultaneouly an extension, the
scheudler i... | 84 | 98 | from __future__ import annotations
import asyncio
import logging
from collections import defaultdict, deque
from math import log2
from time import time
from typing import Container
from tlz import topk
from tornado.ioloop import PeriodicCallback
import dask
from dask.utils import parse_timedelta
from .comm.addressi... |
is_noncomplex | Returns True if *obj* is a special (weird) class, that is more complex
than primitive data types, but is not a full object. Including:
* :class:`~time.struct_time` | # Copyright (C) 2008 John Paulett (john -at- paulett.org)
# Copyright (C) 2009-2018 David Aguilar (davvid -at- gmail.com)
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
"""Helper functions for pickling and unpickling... | def is_noncomplex(obj):
"""Returns True if *obj* is a special (weird) class, that is more complex
than primitive data types, but is not a full object. Including:
* :class:`~time.struct_time`
"""
if type(obj) is time.struct_time:
return True
return False | 250 | 258 | # Copyright (C) 2008 John Paulett (john -at- paulett.org)
# Copyright (C) 2009-2018 David Aguilar (davvid -at- gmail.com)
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
"""Helper functions for pickling and unpickling... |
importable_name | >>> class Example(object):
... pass
>>> ex = Example()
>>> importable_name(ex.__class__) == 'jsonpickle.util.Example'
True
>>> importable_name(type(25)) == 'builtins.int'
True
>>> importable_name(None.__class__) == 'builtins.NoneType'
True
>>> importable_name(False.__class__) == 'builtins.bool'
True
>>> importable... | # Copyright (C) 2008 John Paulett (john -at- paulett.org)
# Copyright (C) 2009-2018 David Aguilar (davvid -at- gmail.com)
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
"""Helper functions for pickling and unpickling... | def importable_name(cls):
"""
>>> class Example(object):
... pass
>>> ex = Example()
>>> importable_name(ex.__class__) == 'jsonpickle.util.Example'
True
>>> importable_name(type(25)) == 'builtins.int'
True
>>> importable_name(None.__class__) == 'builtins.NoneType'
True
>... | 513 | 534 | # Copyright (C) 2008 John Paulett (john -at- paulett.org)
# Copyright (C) 2009-2018 David Aguilar (davvid -at- gmail.com)
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
"""Helper functions for pickling and unpickling... |
__init__ | Init crea
:param str node: Node to connect to *(optional)*
:param str rpcuser: RPC user *(optional)*
:param str rpcpassword: RPC password *(optional)*
:param bool nobroadcast: Do **not** broadcast a transaction!
*(optional)*
:param bool unsigned: Do **not** sign a transaction! *(optional)*
:param bool debug: Enabl... | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... | def __init__(self,
node="",
rpcuser=None,
rpcpassword=None,
debug=False,
data_refresh_time_seconds=900,
**kwargs):
"""Init crea
:param str node: Node to connect to *(optional)*
:par... | 133 | 214 | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... |
get_reward_funds | Get details for a reward fund.
:param bool use_stored_data: if True, stored data will be returned. If stored data are
empty or old, refresh_data() is used. | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... | def get_reward_funds(self, use_stored_data=True):
""" Get details for a reward fund.
:param bool use_stored_data: if True, stored data will be returned. If stored data are
empty or old, refresh_data() is used.
"""
if use_stored_data:
self.refresh_dat... | 333 | 359 | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... |
get_crea_per_mvest | Returns the MVEST to CREA ratio
:param int time_stamp: (optional) if set, return an estimated
CREA per MVEST ratio for the given time stamp. If unset the
current ratio is returned (default). (can also be a datetime object) | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... | def get_crea_per_mvest(self, time_stamp=None, use_stored_data=True):
""" Returns the MVEST to CREA ratio
:param int time_stamp: (optional) if set, return an estimated
CREA per MVEST ratio for the given time stamp. If unset the
current ratio is returned (default).... | 532 | 556 | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... |
sbd_to_vote_pct | Obtain the voting percentage for a desired CBD value
for a given Crea Power or vesting shares and voting power
Give either Crea Power or vests, not both.
When the output is greater than 10000 or smaller than -10000,
the CBD value is too high.
Returns the required voting percentage (100% = 10000)
:param sbd: desired C... | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... | def sbd_to_vote_pct(self, sbd, crea_power=None, vests=None, voting_power=CREA_100_PERCENT, not_broadcasted_vote=True, use_stored_data=True):
""" Obtain the voting percentage for a desired CBD value
for a given Crea Power or vesting shares and voting power
Give either Crea Power or ve... | 728 | 755 | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... |
claim_account | Claim account for claimed account creation.
When fee is 0 CREA a subsidized account is claimed and can be created
later with create_claimed_account.
The number of subsidized account is limited.
:param str creator: which account should pay the registration fee (RC or CREA)
(defaults to ``default_account``)
:pa... | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... | def claim_account(self, creator, fee=None, **kwargs):
""" Claim account for claimed account creation.
When fee is 0 CREA a subsidized account is claimed and can be created
later with create_claimed_account.
The number of subsidized account is limited.
:param... | 1,049 | 1,074 | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... |
custom_json | Create a custom json operation
:param str id: identifier for the custom json (max length 32 bytes)
:param json json_data: the json data to put into the custom_json
operation
:param list required_auths: (optional) required auths
:param list required_posting_auths: (optional) posting auths
.. note:: While reqired a... | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... | def custom_json(self,
id,
json_data,
required_auths=[],
required_posting_auths=[],
**kwargs):
""" Create a custom json operation
:param str id: identifier for the custom json (max length 32 bytes... | 1,567 | 1,607 | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... |
comment_options | Set the comment options
:param dict options: The options to define.
:param str identifier: Post identifier
:param list beneficiaries: (optional) list of beneficiaries
:param str account: (optional) the account to allow access
to (defaults to ``default_account``)
For the options, you have these defaults:::
{
... | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... | def comment_options(self, options, identifier, beneficiaries=[],
account=None, **kwargs):
""" Set the comment options
:param dict options: The options to define.
:param str identifier: Post identifier
:param list beneficiaries: (optional) list of ... | 1,814 | 1,844 | # This Python file uses the following encoding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from builtins import str
from builtins import object
import json
import logging
import re
import os
import math
impor... |
check_closed_path | Checks that data is not changed for the first closed path found. Returns True if data==data after
moving around the closed path, False otherwise. Starting point is current_node | #-----------------------------------------------------------------------------
# Name: GraphModels
# Purpose: To store graphs used in network translations
# Author: Aric Sanders
# Created: 4/6/2016
# License: MIT License
#--------------------------------------------------------------------------... | def check_closed_path(self):
"""Checks that data is not changed for the first closed path found. Returns True if data==data after
moving around the closed path, False otherwise. Starting point is current_node """
temp_data = self.data
path = self.get_path(self.current_node, self.curr... | 615 | 629 | #-----------------------------------------------------------------------------
# Name: GraphModels
# Purpose: To store graphs used in network translations
# Author: Aric Sanders
# Created: 4/6/2016
# License: MIT License
#--------------------------------------------------------------------------... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.