IntelPython / dpnp / 40706202400

83%

Build Type

push

github

Committed by web-flow

Commit Message

Deprecate scalar upcast in `dpnp.append` with `axis=None` (#3125)

`dpnp.append` with `axis=None` converts a Python numeric scalar in
`values` to an array before choosing the result dtype, so the scalar can
upcast `arr`. NumPy 2.6 deprecates this behavior: a future release will
use the Python scalar promotion rules instead, as `concatenate` does.
This PR mirrors that deprecation.

```python
a = dpnp.ones(3, dtype=dpnp.int8)

dpnp.append(a, 1).dtype     # int64, now emits FutureWarning (int8 in the future)
dpnp.append(a, [1]).dtype   # int64, no warning
dpnp.append(a, dpnp.asarray(1, dtype=a.dtype, device=a.device)).dtype  # int8, no warning
```

The result is unchanged, but the call now emits:
```
dpnp.append converted Python numeric scalars to arrays before choosing the result dtype, producing dtype int64. This behavior will change in a future release, these inputs will use dtype int8, which may round values differently or raise an error. Wrap the scalar in a list to keep the current result, or convert it to an array of dtype 'int8' for the future behavior.
```

The warning is emitted only when the dtype will actually change, i.e.
when `dpnp.result_type(arr, values)` differs from the current result
dtype. As in NumPy, only exact Python `int`, `float` and `complex`
scalars are affected; Python `bool`, NumPy scalars, lists and arrays
don't warn. Values out of range for the future dtype (e.g. `300` with a
`uint8` array) will raise `OverflowError` once the change lands.

On devices without fp64 support, a Python `float` or `complex` scalar
already converts to a single-precision array, so e.g. a `float32` array
keeps its dtype and no warning is emitted there.

Coverage Stats

1604 of 2982 branches covered (53.79%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 1 file covered. (100.0%)

6 existing lines in 2 files now uncovered.

29430 of 34569 relevant lines covered (85.13%)

17681.68 hits per line