internlm/SWE-Fixer-Train-110K huggingface dataset:
Repository: google/jax

Issue:
⚠️ Nightly upstream-dev CI failed ⚠️
[Workflow Run URL](https://github.com/google/jax/actions/runs/6431383221)
<details><summary>Summary of Failures</summary>

```
tests/lax_numpy_test.py::NumpyUfuncTests::testUfuncInputTypes11: jaxlib.mlir._mlir_libs._site_initialize.<locals>.MLIRError: Verification failed:
error: "jit(bitwise_count)/jit(main)/abs"("/home/runner/work/jax/jax/tests/lax_numpy_test.py":5461:8): 'stablehlo.abs' op operand #0 must be tensor of 4/8/16/32/64-bit signless integer or f8E4M3B11FNUZ type or f8E4M3FN type or f8E4M3FNUZ type or f8E5M2 type or f8E5M2FNUZ type or 16-bit float or 32-bit float or 64-bit float or bfloat16 type or complex type with 32-bit float or 64-bit float elements or 4/8/16/32-bit uniform quantized signed integer or 4/8/16/32-bit uniform quantized unsigned integer values, but got 'tensor<1xui64>'
 note: "jit(bitwise_count)/jit(main)/abs"("/home/runner/work/jax/jax/tests/lax_numpy_test.py":5461:8): see current operation: %0 = "stablehlo.abs"(%arg0) : (tensor<1xui64>) -> tensor<1xui64>
```

</details>



Discussion:

Resolving patch:
diff --git a/jax/_src/numpy/ufuncs.py b/jax/_src/numpy/ufuncs.py
--- a/jax/_src/numpy/ufuncs.py
+++ b/jax/_src/numpy/ufuncs.py
@@ -201,7 +201,7 @@ def arccosh(x: ArrayLike, /) -> Array:
 @jit
 def bitwise_count(x: ArrayLike, /) -> Array:
   # Following numpy we take the absolute value and return uint8.
-  return lax.population_count(lax.abs(x)).astype('uint8')
+  return lax.population_count(abs(x)).astype('uint8')
 
 @_wraps(np.right_shift, module='numpy')
 @partial(jit, inline=True)


Test patch:
diff --git a/tests/lax_numpy_operators_test.py b/tests/lax_numpy_operators_test.py
--- a/tests/lax_numpy_operators_test.py
+++ b/tests/lax_numpy_operators_test.py
@@ -576,7 +576,7 @@ def testBitwiseOp(self, name, rng_factory, shapes, dtypes):
 
   @jtu.sample_product(
     shape=array_shapes,
-    dtype=int_dtypes,
+    dtype=int_dtypes + unsigned_dtypes,
   )
   def testBitwiseCount(self, shape, dtype):
     # np.bitwise_count added after numpy 1.26, but
Repository: google/jax

Issue:
Documentation for jax.pure_callback does not mention ShapeDtypeStruct
### Description

The documentation page for `jax.pure_callback` states that `result_shape_dtypes` needs to be a PyTree whose leaves have `shape` and `dtype` members, but does not mention `jax.ShapeDtypeStruct` that already has those fields. An example in that documentation page would also be helpful, as would better errors for users who pass a raw shape instead of a structure as that argument.

### What jax/jaxlib version are you using?

_No response_

### Which accelerator(s) are you using?

_No response_

### Additional system info

_No response_

### NVIDIA GPU info

_No response_


Discussion:

Resolving patch:
diff --git a/jax/_src/callback.py b/jax/_src/callback.py
--- a/jax/_src/callback.py
+++ b/jax/_src/callback.py
@@ -234,6 +234,7 @@ def pure_callback(
       may behave in unexpected ways, particularly under transformation.
     result_shape_dtypes: pytree whose leaves have ``shape`` and ``dtype`` attributes,
       whose structure matches the expected output of the callback function at runtime.
+      :class:`jax.ShapeDtypeStruct` is often used to define leaf values.
     *args: arguments to be passed to the callback function
     sharding: optional sharding that specifies the device from which the callback should
       be invoked.
@@ -480,6 +481,7 @@ def io_callback(
       more efficient execution.
     result_shape_dtypes: pytree whose leaves have ``shape`` and ``dtype`` attributes,
       whose structure matches the expected output of the callback function at runtime.
+      :class:`jax.ShapeDtypeStruct` is often used to define leaf values.
     *args: arguments to be passed to the callback function
     sharding: optional sharding that specifies the device from which the callback should
       be invoked.


Test patch:
Repository: google/jax

Issue:
The default argument optimize of einsum in the document is 'optimal', not False.
### Description

The default argument optimize of einsum in the document is 'optimal', not False.

It seems like the documentation comes directly from numpy and jax changes the defaults.

<img width="930" alt="Screenshot 2023-10-29 at 1 57 19 PM" src="https://github.com/google/jax/assets/5007613/ee7adac3-9086-4caf-a99b-3816764be545">

<img width="843" alt="Screenshot 2023-10-29 at 2 00 26 PM" src="https://github.com/google/jax/assets/5007613/8bbee68c-fcb6-4dea-9f11-38aa0ccfd88d">


### What jax/jaxlib version are you using?

_No response_

### Which accelerator(s) are you using?

_No response_

### Additional system info

_No response_

### NVIDIA GPU info

_No response_


Discussion:
Thanks - you're correct that the documentation comes straight from NumPy (we note that with *original documentation below* at the top of the docstring). We can add a note about the different default value at the top of the JAX docstring.

Resolving patch:
diff --git a/jax/_src/numpy/lax_numpy.py b/jax/_src/numpy/lax_numpy.py
--- a/jax/_src/numpy/lax_numpy.py
+++ b/jax/_src/numpy/lax_numpy.py
@@ -3296,6 +3296,9 @@ def tensordot(a: ArrayLike, b: ArrayLike,
 A tuple ``precision`` does not necessarily map to multiple arguments of ``einsum()``;
 rather, the specified ``precision`` is forwarded to each ``dot_general`` call used in
 the implementation.
+
+:func:`jax.numpy.einsum` also differs from :func:`numpy.einsum` in that the ``optimize``
+keyword defaults to ``"optimal"`` rather than ``False``.
 """
 
 @overload


Test patch:
Repository: google/jax

Issue:
jnp.nanmean can overflow in the denominator for large arguments
### Description

The following reproduces a phenomenon where the mean of a positive tensor can be negative:
```python
logits = np.random.uniform(size=[2048,64, 32000], low=-4, high=4)
jnp.nanmean(jnp.abs(logits))
=> DeviceArray(-83.333984, dtype=float32)
```

The reason is that the mean normalizer is summed using `np.int32` here: https://github.com/google/jax/blob/540835f979fe13a968f69b894dbafc981f122b36/jax/_src/numpy/reductions.py#L586

The error is silent.

A workaround is to split the mean along two or more axes.

A stopgap fix would be to throw an error if the tensor is too large, so that the user can decide how to deal with it.

Another fix would be to sum in int64.

### What jax/jaxlib version are you using?

_No response_

### Which accelerator(s) are you using?

_No response_

### Additional system info

_No response_

### NVIDIA GPU info

_No response_


Discussion:
Thanks for the report – I vaguely recall this coming up recently in the context of `var` as well.

Perhaps since we end up converting to float in the end anyway, a better fix would be to accumulate the normalizer in float to avoid this kind of overflow? I'm trying to think whether there would be any downsides to that.

Resolving patch:
diff --git a/jax/_src/numpy/reductions.py b/jax/_src/numpy/reductions.py
--- a/jax/_src/numpy/reductions.py
+++ b/jax/_src/numpy/reductions.py
@@ -587,16 +587,17 @@ def nanprod(a: ArrayLike, axis: Axis = None, dtype: Optional[DTypeLike] = None,
 def nanmean(a: ArrayLike, axis: Axis = None, dtype: Optional[DTypeLike] = None, out: None = None,
             keepdims: bool = False, where: Optional[ArrayLike] = None) -> Array:
   check_arraylike("nanmean", a)
-  dtypes.check_user_dtype_supported(dtype, "nanmean")
   if out is not None:
     raise NotImplementedError("The 'out' argument to jnp.nanmean is not supported.")
   if dtypes.issubdtype(dtypes.dtype(a), np.bool_) or dtypes.issubdtype(dtypes.dtype(a), np.integer):
     return mean(a, axis, dtype, out, keepdims, where=where)
   if dtype is None:
-    dtype = dtypes.dtype(a)
+    dtype = dtypes.to_inexact_dtype(dtypes.dtype(a, canonicalize=True))
+  else:
+    dtypes.check_user_dtype_supported(dtype, "mean")
+    dtype = dtypes.canonicalize_dtype(dtype)
   nan_mask = lax_internal.bitwise_not(lax_internal._isnan(a))
-  normalizer = sum(nan_mask, axis=axis, dtype=np.int32, keepdims=keepdims, where=where)
-  normalizer = lax.convert_element_type(normalizer, dtype)
+  normalizer = sum(nan_mask, axis=axis, dtype=dtype, keepdims=keepdims, where=where)
   td = lax.div(nansum(a, axis, dtype=dtype, keepdims=keepdims, where=where), normalizer)
   return td
 


Test patch:
Repository: google/jax

Issue:
Array indexing: boolean mask after `newaxis` leads to error
Working example in NumPy:
```python
import numpy as np
x = np.arange(6).reshape(2, 3)
mask = np.array([True, True])
x[np.newaxis, mask]
# array([[[0, 1, 2],
#         [3, 4, 5]]])
```
Error in JAX:
```python
import jax.numpy as jnp
x = jnp.arange(6).reshape(2, 3)
mask = jnp.array([True, True])
x[jnp.newaxis, mask]
# IndexError: boolean index did not match shape of indexed array in index 1: got (2,), expected (3,)
```


Discussion:

Resolving patch:
diff --git a/jax/_src/numpy/lax_numpy.py b/jax/_src/numpy/lax_numpy.py
--- a/jax/_src/numpy/lax_numpy.py
+++ b/jax/_src/numpy/lax_numpy.py
@@ -4774,6 +4774,7 @@ def _expand_bool_indices(idx, shape):
     total_dims = sum(_ndim(e) if _is_boolean_index(e) else 1 for e in idx
                      if e is not None and e is not Ellipsis)
   ellipsis_offset = 0
+  newaxis_offset = 0
   for dim_number, i in enumerate(idx):
     try:
       abstract_i = core.get_aval(i)
@@ -4791,7 +4792,7 @@ def _expand_bool_indices(idx, shape):
         raise TypeError("JAX arrays do not support boolean scalar indices")
       else:
         i_shape = _shape(i)
-        start = len(out) + ellipsis_offset
+        start = len(out) + ellipsis_offset - newaxis_offset
         expected_shape = shape[start: start + _ndim(i)]
         if i_shape != expected_shape:
           raise IndexError("boolean index did not match shape of indexed array in index "
@@ -4801,6 +4802,8 @@ def _expand_bool_indices(idx, shape):
       out.append(i)
     if i is Ellipsis:
       ellipsis_offset = len(shape) - total_dims - 1
+    if i is None:
+      newaxis_offset += 1
   return tuple(out)
 
 


Test patch:
diff --git a/tests/lax_numpy_indexing_test.py b/tests/lax_numpy_indexing_test.py
--- a/tests/lax_numpy_indexing_test.py
+++ b/tests/lax_numpy_indexing_test.py
@@ -974,6 +974,30 @@ def testBooleanIndexingShapeMismatch(self):
     with self.assertRaisesRegex(IndexError, "boolean index did not match shape.*"):
       x[idx]
 
+  def testBooleanIndexingWithNone(self):
+    # Regression test for https://github.com/google/jax/issues/18542
+    x = jnp.arange(6).reshape(2, 3)
+    idx = (None, jnp.array([True, False]))
+    ans = x[idx]
+    expected = jnp.arange(3).reshape(1, 1, 3)
+    self.assertAllClose(ans, expected)
+
+  def testBooleanIndexingWithNoneAndEllipsis(self):
+    # Regression test for https://github.com/google/jax/issues/18542
+    x = jnp.arange(6).reshape(2, 3)
+    mask = jnp.array([True, False, False])
+    ans = x[None, ..., mask]
+    expected = jnp.array([0, 3]).reshape(1, 2, 1)
+    self.assertAllClose(ans, expected)
+
+  def testBooleanIndexingWithEllipsisAndNone(self):
+    # Regression test for https://github.com/google/jax/issues/18542
+    x = jnp.arange(6).reshape(2, 3)
+    mask = jnp.array([True, False, False])
+    ans = x[..., None, mask]
+    expected = jnp.array([0, 3]).reshape(2, 1, 1)
+    self.assertAllClose(ans, expected)
+
   def testNontrivialBooleanIndexing(self):
     # Test nontrivial corner case in boolean indexing shape validation
     rng = jtu.rand_default(self.rng())
Repository: google/jax

Issue:
NaN Error only in combination of `disable_jit` and `debug_nans`
Is this expected behavior?
(jax+jaxlib 0.4.20)

```python
from jax import config
config.update("jax_debug_nans", True)
config.update('jax_disable_jit', True)

import jax.numpy as jnp
import jax

xp = jnp.array([0.        , 0.16      , 0.35      , 0.39999998, 0.53999996,
        0.62      , 0.78999996, 0.95      , 1.25      , 1.36      ,
        1.43      , 1.5799999 , 1.77      , 1.86      , 1.9499999 ,
        2.02      , 2.09      , 2.29      , 2.52      , 2.74      ,
        2.8899999 , 3.1499999 , 3.35      , 3.4499998 , 3.59      ,
        3.8       , 3.86      , 4.06      , 4.2       , 4.46      ,
        4.62      , 4.8599997 , 4.97      , 5.15      , 5.15      ,
      ])

x = jnp.arange(0, 5.0, step=0.01)
@jax.jit
def f(x, xp):
    return jnp.searchsorted(xp, x, side="right")

# throws error only if both config flags are enabled
f(x, xp)
```
throws `FloatingPointError: invalid value (nan) encountered in jit(convert_element_type)` 

Edit: Ops sorry i must have clicked on enhancement, but this is a potential bug report.


Discussion:
As is stated in `jax_debug_nans`'s [limitations](https://jax.readthedocs.io/en/latest/debugging/flags.html#limitations), `jax_debug_nans` could produce
> Errors on false positives (e.g. intentionally created NaNs)

This might be the case for `searchsorted`, because IEEE754 floating-point numbers do not have a total ordering and a correct `searchsorted` should deal with `nan` appropriately. This is done by `nan values are sorted to the end`. Meanwhile, some explicitly-created `nan` might be involved in this process.

Resolving patch:
diff --git a/jax/_src/lax/lax.py b/jax/_src/lax/lax.py
--- a/jax/_src/lax/lax.py
+++ b/jax/_src/lax/lax.py
@@ -4055,7 +4055,8 @@ def _canonicalize_float_for_sort(x):
   # and NaNs in the output.
 
   result = select(eq(x, _zero(x)), _zeros(x), x)
-  result = select(_isnan(x), full_like(result, np.nan), result)
+  with jax.debug_nans(False):
+    result = select(_isnan(x), full_like(result, np.nan), result)
 
   return result
 


Test patch:
Repository: google/jax

Issue:
The gradient of `i0` for input 0 should be 0
Based on the definition of `i0`, its gradient for input 0 should be 0. It is differentiable at the point 0, unlike `abs`

```py
import jax

a = jax.numpy.array([0.])
print(jax.jacrev(jax.numpy.i0)(a))
# [[1.]]
# It should be 0
```


Discussion:
any update of this bug?
Thanks - sorry this fell through the cracks. It looks like this could be fixed by adding a custom JVP rule to `jax.numpy.i0`. Is this something you'd be interested in contributing? If not we can have someone on the team take care of it.

Resolving patch:
diff --git a/jax/_src/numpy/lax_numpy.py b/jax/_src/numpy/lax_numpy.py
--- a/jax/_src/numpy/lax_numpy.py
+++ b/jax/_src/numpy/lax_numpy.py
@@ -49,6 +49,7 @@
 from jax._src import api_util
 from jax._src import config
 from jax._src import core
+from jax._src.custom_derivatives import custom_jvp
 from jax._src import dispatch
 from jax._src import dtypes
 from jax._src.api_util import _ensure_index_tuple
@@ -2644,6 +2645,7 @@ def meshgrid(*xi: ArrayLike, copy: bool = True, sparse: bool = False,
   return output
 
 
+@custom_jvp
 @util._wraps(np.i0)
 @jit
 def i0(x: ArrayLike) -> Array:
@@ -2653,6 +2655,11 @@ def i0(x: ArrayLike) -> Array:
   x_arr = lax.abs(x_arr)
   return lax.mul(lax.exp(x_arr), lax.bessel_i0e(x_arr))
 
+@i0.defjvp
+def _i0_jvp(primals, tangents):
+  primal_out, tangent_out = jax.jvp(i0.fun, primals, tangents)
+  return primal_out, where(primals[0] == 0, 0.0, tangent_out)
+
 
 @util._wraps(np.ix_)
 def ix_(*args: ArrayLike) -> tuple[Array, ...]:


Test patch:
diff --git a/tests/lax_numpy_operators_test.py b/tests/lax_numpy_operators_test.py
--- a/tests/lax_numpy_operators_test.py
+++ b/tests/lax_numpy_operators_test.py
@@ -641,6 +641,11 @@ def __rmul__(self, other):
     self.assertIsInstance(b * a, MyArray)
     self.assertIsInstance(jax.jit(operator.mul)(b, a), MyArray)
 
+  def testI0Grad(self):
+    # Regression test for https://github.com/google/jax/issues/11479
+    dx = jax.grad(jax.numpy.i0)(0.0)
+    self.assertArraysEqual(dx, 0.0)
+
 
 if __name__ == "__main__":
   absltest.main(testLoader=jtu.JaxTestLoader())
Repository: google/jax

Issue:
Should `array_equal` and `array_equiv` enforce array like for their arguments?
Type hints says yes, yet they are permissive in their arguments.
```python
jnp.array_equal(np.array([1, 2, 3]), [1, 2, 3])
# Array(True)
```

Does #7737 apply here?


Discussion:
Yes, it probably should. We’ve been slow to implement #7737 because every change is an API breakage that needs a deprecation cycle, and that can be difficult to land due to necessary downstream changes.

Resolving patch:
diff --git a/jax/_src/numpy/lax_numpy.py b/jax/_src/numpy/lax_numpy.py
--- a/jax/_src/numpy/lax_numpy.py
+++ b/jax/_src/numpy/lax_numpy.py
@@ -2298,7 +2298,12 @@ def _check_forgot_shape_tuple(name, shape, dtype) -> str | None:  # type: ignore
 def array_equal(a1: ArrayLike, a2: ArrayLike, equal_nan: bool = False) -> Array:
   try:
     a1, a2 = asarray(a1), asarray(a2)
-  except Exception:
+  except Exception as err:
+    # TODO(jakevdp): Deprecated 2023-11-23; change to error.
+    warnings.warn("Inputs to array_equal() cannot be coerced to array. "
+                  "Returning False; in the future this will raise an exception.\n"
+                  f"{err!r}",
+                  DeprecationWarning, stacklevel=2)
     return bool_(False)
   if shape(a1) != shape(a2):
     return bool_(False)
@@ -2312,7 +2317,12 @@ def array_equal(a1: ArrayLike, a2: ArrayLike, equal_nan: bool = False) -> Array:
 def array_equiv(a1: ArrayLike, a2: ArrayLike) -> Array:
   try:
     a1, a2 = asarray(a1), asarray(a2)
-  except Exception:
+  except Exception as err:
+    # TODO(jakevdp): Deprecated 2023-11-23; change to error.
+    warnings.warn("Inputs to array_equiv() cannot be coerced to array. "
+                  "Returning False; in the future this will raise an exception.\n"
+                  f"{err!r}",
+                  DeprecationWarning, stacklevel=2)
     return bool_(False)
   try:
     eq = ufuncs.equal(a1, a2)


Test patch:
Repository: google/jax

Issue:
BCOO matrix shape behaves differently than dense matrices
### Description

Not a big issue... but this behavior confused me. 

```
import jax.numpy as jnp
from jax import jit

i = jnp.int32(1)

# I was able to fix my issue with BCOO by casting to a python int dtype
# i = int(i) 

array_shape = (i,)
m_dense = jnp.ones(shape=array_shape)
m_sparse = BCOO((jnp.array([1]), jnp.array([[0]])), shape=array_shape)

# Should be the same?
print(m_dense.shape) # --> (1,)
print(m_sparse.shape) # --> (Array(1, dtype=int32),)
print(m_sparse.todense().shape) # --> (1,)

jit(lambda _: m_dense[0])(None) # Works fine
jit(lambda _: m_sparse[0])(None) # Throws TracerBoolConversionError

```


### What jax/jaxlib version are you using?

jax==0.4.14 jaxlib==0.4.14+cuda12.cudnn89

### Which accelerator(s) are you using?

GPU

### Additional system info

_No response_

### NVIDIA GPU info

_No response_


Discussion:
Thanks for the report – the shape is meant to be a sequence of integers, not a sequence of arrays: https://github.com/google/jax/blob/7224c24521b4bbd25af3ed3619cd59d377d6828e/jax/experimental/sparse/bcoo.py#L2469

It seems the implementation never validates this, but you may encounter errors if you pass unexpected values!

Resolving patch:
diff --git a/jax/experimental/sparse/_base.py b/jax/experimental/sparse/_base.py
--- a/jax/experimental/sparse/_base.py
+++ b/jax/experimental/sparse/_base.py
@@ -16,6 +16,7 @@
 import abc
 from collections.abc import Sequence
 import math
+import operator
 
 import jax
 from jax._src import core
@@ -44,7 +45,7 @@ def ndim(self) -> int:
     return len(self.shape)
 
   def __init__(self, args: tuple[Array, ...], *, shape: Sequence[int]):
-    self.shape = tuple(shape)
+    self.shape = core.canonicalize_shape(shape)
 
   def __repr__(self):
     name = self.__class__.__name__


Test patch:
Repository: google/jax

Issue:
Add replication rules for convolutions
### Description

I'm running with shard_map in an attempt to replicate my previous pmap setup and am getting the following:

```
error:NotImplementedError: No replication rule for conv_general_dilated. As a workaround, pass the `check_rep=False` argument to `shard_map`. To get this fixed, open an issue at https://github.com/google/jax/issues
```

### What jax/jaxlib version are you using?

0.4.20 0.4.18

### Which accelerator(s) are you using?

CPU/GPU/TPU

### Additional system info?

_No response_

### NVIDIA GPU info

_No response_


Discussion:

Resolving patch:
diff --git a/jax/experimental/shard_map.py b/jax/experimental/shard_map.py
--- a/jax/experimental/shard_map.py
+++ b/jax/experimental/shard_map.py
@@ -46,7 +46,8 @@
 from jax._src.core import Tracer
 from jax._src.api import _shared_code_pmap, _prepare_pmap
 from jax._src.lax import (lax, parallel as lax_parallel, slicing,
-                          windowed_reductions, fft, linalg, control_flow)
+                          windowed_reductions, convolution, fft, linalg,
+                          control_flow)
 from jax._src.util import (HashableFunction, HashablePartial, unzip2, unzip3,
                            as_hashable_function, memoize, partition_list,
                            merge_lists, split_list, subs_list2)
@@ -966,7 +967,8 @@ def _standard_collective_rewrite(prim, mesh, in_rep, x, axis_name, **params):
 
 
 for o in it.chain(lax.__dict__.values(), slicing.__dict__.values(),
-                  windowed_reductions.__dict__.values(), fft.__dict__.values(),
+                  windowed_reductions.__dict__.values(),
+                  convolution.__dict__.values(), fft.__dict__.values(),
                   linalg.__dict__.values(), ops.__dict__.values(),
                   ad_util.__dict__.values(), prng.__dict__.values()):
   if isinstance(o, core.Primitive):


Test patch:
diff --git a/tests/shard_map_test.py b/tests/shard_map_test.py
--- a/tests/shard_map_test.py
+++ b/tests/shard_map_test.py
@@ -1264,6 +1264,22 @@ def f(x):
 
     jax.grad(loss)(3.0, jnp.arange(8.))  # don't crash
 
+  def test_conv_general_dilated(self):
+    mesh = jtu.create_global_mesh((4,), ('i',))
+
+    dot = partial(lax.conv_general_dilated, window_strides=(),
+                   padding='VALID', dimension_numbers=('NC', 'IO', 'NC'))
+
+    @partial(shard_map, mesh=mesh, in_specs=(P(None, 'i'), P('i', None)),
+             out_specs=P(None, None))
+    def f(x, y):
+      return lax.psum(dot(x, y), 'i')
+
+    a = jnp.ones((16, 32))
+    b = jnp.ones((32, 8))
+    y = f(a, b)  # don't crash
+    self.assertAllClose(y, a @ b, check_dtypes=False, atol=1e-2, rtol=1e-2)
+
 
 class FunSpec(NamedTuple):
   name: str