array-api-strict 2.5__tar.gz → 2.6__tar.gz

{array_api_strict-2.5 → array_api_strict-2.6}/.github/dependabot.yml

@@ -5,6 +5,8 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
+    cooldown:
+      default-days: 7     # optional
     groups:
       actions:
         patterns:

{array_api_strict-2.5 → array_api_strict-2.6}/.github/workflows/array-api-tests.yml

@@ -11,11 +11,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
-        numpy-version: ['1.26', '2.3.5', 'dev']
+        python-version: ['3.10', '3.13', '3.14']
+        numpy-version: ['1.26', 'latest', 'dev']
         exclude:
           - python-version: '3.10'
-            numpy-version: '2.3.5'
+            numpy-version: 'latest'
           - python-version: '3.10'
             numpy-version: 'dev'            
           - python-version: '3.13'
@@ -25,17 +25,17 @@ jobs:
       fail-fast: false
     steps:
     - name: Checkout array-api-strict
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7.0.0
       with:
         path: array-api-strict
     - name: Checkout array-api-tests
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7.0.0
       with:
         repository: data-apis/array-api-tests
         submodules: 'true'
         path: array-api-tests
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v6
+      uses: actions/setup-python@v6.3.0
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install Dependencies
@@ -43,6 +43,8 @@ jobs:
         python -m pip install --upgrade pip
         if [[ "${{ matrix.numpy-version }}" == "dev" ]]; then
           python -m pip install --pre --extra-index https://pypi.anaconda.org/scientific-python-nightly-wheels/simple numpy;
+        elif [[ "${{ matrix.numpy-version }}" == "latest" ]]; then
+          python -m pip install numpy
         else
           python -m pip install 'numpy=='${{ matrix.numpy-version }};
         fi

{array_api_strict-2.5 → array_api_strict-2.6}/.github/workflows/dependabot-auto-merge.yml

@@ -13,7 +13,7 @@ jobs:
     steps:
       - name: Dependabot metadata
         id: metadata
-        uses: dependabot/fetch-metadata@v2
+        uses: dependabot/fetch-metadata@v3
         with:
           github-token: "${{ secrets.GITHUB_TOKEN }}"
       - name: Enable auto-merge for Dependabot PRs

{array_api_strict-2.5 → array_api_strict-2.6}/.github/workflows/docs-build.yml

@@ -6,8 +6,8 @@ jobs:
   docs-build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
+      - uses: actions/checkout@v7.0.0
+      - uses: actions/setup-python@v6.3.0
       - name: Install Dependencies
         run: |
           python -m pip install -r docs/requirements.txt
@@ -16,7 +16,7 @@ jobs:
           cd docs
           make html
       - name: Upload Artifact
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: docs-build
           path: docs/_build/html

{array_api_strict-2.5 → array_api_strict-2.6}/.github/workflows/docs-deploy.yml

@@ -11,9 +11,9 @@ jobs:
     environment:
       name: docs-deploy
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7.0.0
       - name: Download Artifact
-        uses: dawidd6/action-download-artifact@v14
+        uses: dawidd6/action-download-artifact@v21
         with:
           workflow: docs-build.yml
           name: docs-build

{array_api_strict-2.5 → array_api_strict-2.6}/.github/workflows/publish-package.yml

@@ -30,12 +30,12 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v7.0.0
       with:
         fetch-depth: 0
 
     - name: Set up Python
-      uses: actions/setup-python@v6
+      uses: actions/setup-python@v6.3.0
       with:
         python-version: '3.x'
 
@@ -62,7 +62,7 @@ jobs:
       run: python -m zipfile --list dist/array_api_strict-*.whl
 
     - name: Upload distribution artifact
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v7
       with:
         name: dist-artifact
         path: dist
@@ -83,7 +83,7 @@ jobs:
 
     steps:
     - name: Download distribution artifact
-      uses: actions/download-artifact@v7
+      uses: actions/download-artifact@v8
       with:
         name: dist-artifact
         path: dist
@@ -97,19 +97,19 @@ jobs:
     #   if: >-
     #     (github.event_name == 'push' && startsWith(github.ref, 'refs/tags'))
     #     || (github.event_name == 'workflow_dispatch' && github.event.inputs.publish == 'true')
-    #   uses: pypa/gh-action-pypi-publish@v1.13.0
+    #   uses: pypa/gh-action-pypi-publish@v1.14.0
     #   with:
     #     repository-url: https://test.pypi.org/legacy/
     #     print-hash: true
 
     - name: Publish distribution 📦 to PyPI
       if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags')
-      uses: pypa/gh-action-pypi-publish@v1.13.0
+      uses: pypa/gh-action-pypi-publish@v1.14.0
       with:
         print-hash: true
 
     - name: Create GitHub Release from a Tag
-      uses: softprops/action-gh-release@v2
+      uses: softprops/action-gh-release@v3
       if: startsWith(github.ref, 'refs/tags/')
       with:
           files: dist/*

{array_api_strict-2.5 → array_api_strict-2.6}/.github/workflows/ruff.yml

@@ -5,9 +5,9 @@ jobs:
     runs-on: ubuntu-latest
     continue-on-error: true
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7.0.0
       - name: Install Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v6.3.0
         with:
           python-version: "3.11"
       - name: Install dependencies

{array_api_strict-2.5 → array_api_strict-2.6}/.github/workflows/tests.yml

@@ -5,11 +5,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
-        numpy-version: ['1.26', '2.3.5', 'dev']
+        python-version: ['3.10', '3.13', '3.14']
+        numpy-version: ['1.26', 'latest', 'dev']
         exclude:
           - python-version: '3.10'
-            numpy-version: '2.3.5'
+            numpy-version: 'latest'
           - python-version: '3.10'
             numpy-version: 'dev'            
           - python-version: '3.13'
@@ -18,8 +18,8 @@ jobs:
             numpy-version: '1.26'
       fail-fast: false
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
+      - uses: actions/checkout@v7.0.0
+      - uses: actions/setup-python@v6.3.0
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install Dependencies
@@ -27,6 +27,8 @@ jobs:
           python -m pip install --upgrade pip
           if [[ "${{ matrix.numpy-version }}" == "dev" ]]; then
             python -m pip install --pre --extra-index https://pypi.anaconda.org/scientific-python-nightly-wheels/simple numpy;
+          elif [[ "${{ matrix.numpy-version }}" == "latest" ]]; then
+            python -m pip install numpy
           else
             python -m pip install 'numpy=='${{ matrix.numpy-version }}
           fi

{array_api_strict-2.5 → array_api_strict-2.6}/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 2.6 (2026-07-09)
+
+- `__setitem__` method of array objects got stricter:
+
+   - `__setitem__` method now disallows device transfers: if the right-hand side
+     argument is an array on a device which differs from the device of the left-hand
+     argument, an error is raised. Note that this change follows
+     the draft of a future Array API standard revision, see
+     [gh-1005](https://github.com/data-apis/array-api/pull/1005) for discussion.
+   - `None` is no longer allowed as an indexing key. 
+
+- Array objects expose a DLPack device number, via their `__dlpack_device__` method.
+- `from_dlpack` function now supports `copy=` argument.
+
+- `Device` objects are now allowed to only support a subset of data types, and can
+  have a device-dependent default data types. Note that this enhancement follows
+  the draft of a future Array API standard revision, see
+  [gh-1005](https://github.com/data-apis/array-api/pull/1005) for discussion.
+  - A new device object, `Device("no_float64")` was added which only supports
+    single-precision float and complex data types; this device mimics the behavior
+    of a "metal"/MPS device which does not support double precision floats.
+    Attempting to create an array with float64 or complex128 data type on this device
+    raises an error.
+  - The existing `Device("device2")` object has been modified: it supports float64 data
+    type but defaults to float32 and complex64:
+    `asarray([1.0], device=Device("device2")).dtype` is `float32`.
+
+
+### Contributors
+
+The following users contributed to this release:
+
+Evgeni Burovski,
+Lucas Colley,
+Ralf Gommers,
+Tim Head.
+
+
 ## 2.5 (2026-02-23)
 
 This release targets the 2025.12 revision of the Array API standard, and supports

{array_api_strict-2.5/array_api_strict.egg-info → array_api_strict-2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: array_api_strict
-Version: 2.5
+Version: 2.6
 Summary: A strict, minimal implementation of the Python array API standard.
 Author: Consortium for Python Data API Standards
 License: Copyright (c) 2021-2024, NumPy Developers, Consortium for Python Data API Standards

{array_api_strict-2.5 → array_api_strict-2.6}/array-api-tests-xfails.txt

@@ -45,3 +45,10 @@ array_api_tests/test_special_cases.py::test_unary[tanh(real(x_i) is +infinity an
 array_api_tests/test_special_cases.py::test_unary[acosh(real(x_i) is +0 and imag(x_i) is NaN) -> NaN \xb1 \u03c0j/2]
 
 array_api_tests/test_special_cases.py::test_unary[sqrt(real(x_i) is +infinity and isfinite(imag(x_i)) and imag(x_i) > 0) -> +0 + infinity j]
+
+# remove this when array-api-strict 2.6 is released: this is only for array-api-tests,
+# which runs self-tests against a released array-api-strict
+array_api_tests/test_dlpack.py::test_from_dlpack
+
+# NumPy 1.26 : NotImplementedError: The copy argument to __dlpack__ is not yet implemented
+array_api_tests/test_dlpack.py::test_dunder_dlpack

{array_api_strict-2.5 → array_api_strict-2.6}/array_api_strict/_array_object.py

@@ -20,7 +20,7 @@ import sys
 from collections.abc import Iterator
 from enum import IntEnum
 from types import EllipsisType, ModuleType
-from typing import Any, Final, Literal, SupportsIndex, Callable
+from typing import Any, Literal, SupportsIndex, Callable
 
 import numpy as np
 import numpy.typing as npt
@@ -40,35 +40,14 @@ from ._dtypes import (
     _real_to_complex_map,
     _result_type,
 )
+from ._devices import (
+    CPU_DEVICE, Device, device_supports_dtype, _normalize_dl_device, _DLPACK_DEVICE_FOR,
+    DLDeviceType
+)
 from ._flags import get_array_api_strict_flags, set_array_api_strict_flags
 from ._typing import PyCapsule
 
 
-class Device:
-    _device: Final[str]
-    __slots__ = ("_device", "__weakref__")
-
-    def __init__(self, device: str = "CPU_DEVICE"):
-        if device not in ("CPU_DEVICE", "device1", "device2"):
-            raise ValueError(f"The device '{device}' is not a valid choice.")
-        self._device = device
-
-    def __repr__(self) -> str:
-        return f"array_api_strict.Device('{self._device}')"
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Device):
-            return False
-        return self._device == other._device
-
-    def __hash__(self) -> int:
-        return hash(("Device", self._device))
-
-
-CPU_DEVICE = Device()
-ALL_DEVICES = (CPU_DEVICE, Device("device1"), Device("device2"))
-
-
 class Array:
     """
     n-d array object for the array API namespace.
@@ -113,10 +92,15 @@ class Array:
             raise TypeError(
                 f"The array_api_strict namespace does not support the dtype '{x.dtype}'"
             )
-        obj._array = x
-        obj._dtype = _dtype
+
         if device is None:
             device = CPU_DEVICE
+        if not device_supports_dtype(device, _dtype):
+            raise ValueError(f"Device {device!r} does not support dtype={_dtype!r}.")
+
+        obj._array = x
+        obj._dtype = _dtype
+
         obj._device = device
         return obj
 
@@ -400,7 +384,7 @@ class Array:
                 isinstance(i, SupportsIndex)  # i.e. ints
                 or isinstance(i, slice)
                 or i == Ellipsis
-                or i is None
+                or (op == "getitem" and i is None) # `None` disallowed in setitem
                 or isinstance(i, Array)
                 or isinstance(i, np.ndarray)
             ):
@@ -630,22 +614,40 @@ class Array:
                 raise NotImplementedError("The copy argument to __dlpack__ is not yet implemented")
 
             return self._array.__dlpack__(stream=stream)
-        else:
-            kwargs = {'stream': stream}
-            if max_version is not _undef:
-                kwargs['max_version'] = max_version
-            if dl_device is not _undef:
-                kwargs['dl_device'] = dl_device
-            if copy is not _undef:
-                kwargs['copy'] = copy
-            return self._array.__dlpack__(**kwargs)
+
+        kwargs: dict[str, Any] = {'stream': stream}
+        self_dl_device = _normalize_dl_device(*_DLPACK_DEVICE_FOR[self._device])
+        cpu_dl_device = _normalize_dl_device(DLDeviceType.kDLCPU, 0)
+        numpy_dl_device: tuple[IntEnum, int] | None = None
+
+        if dl_device not in [_undef, None]:
+            requested = _normalize_dl_device(dl_device[0], dl_device[1])
+            if requested == self_dl_device:
+                pass
+            elif requested == cpu_dl_device and self_dl_device != cpu_dl_device:
+                if copy is False:
+                    raise BufferError(
+                        "Cannot export array to CPU without copying when copy=False"
+                    )
+                if copy is _undef:
+                    copy = True
+                numpy_dl_device = (DLDeviceType.kDLCPU, 0)
+            else:
+                raise BufferError("unsupported device requested")
+
+        if max_version is not _undef:
+            kwargs['max_version'] = max_version
+        if numpy_dl_device is not None:
+            kwargs['dl_device'] = numpy_dl_device
+        if copy is not _undef:
+            kwargs['copy'] = copy
+        return self._array.__dlpack__(**kwargs)
 
     def __dlpack_device__(self) -> tuple[IntEnum, int]:
         """
         Performs the operation __dlpack_device__.
         """
-        # Note: device support is required for this
-        return self._array.__dlpack_device__()
+        return _DLPACK_DEVICE_FOR[self._device]
 
     def __eq__(self, other: Array | complex, /) -> Array:  # type: ignore[override]
         """
@@ -960,6 +962,10 @@ class Array:
         other = value
         if isinstance(value, (bool, int, float, complex)):
             other = self._promote_scalar(value)
+        else:
+            if value.device != self.device:
+                raise ValueError(f"mismatched devices: {self.device = } != {value.device =}.")
+
         dt = _result_type(self.dtype, other.dtype)
         if dt != self.dtype:
             raise TypeError(f"mismatched dtypes: {self.dtype = } and {other.dtype = }")

{array_api_strict-2.5 → array_api_strict-2.6}/array_api_strict/_creation_functions.py

@@ -5,7 +5,11 @@ from typing import TYPE_CHECKING, Literal
 
 import numpy as np
 
-from ._dtypes import DType, _all_dtypes, _np_dtype
+from ._dtypes import DType, _all_dtypes, _np_dtype, bool as xp_bool
+from ._devices import (
+    Device, device_supports_dtype, get_default_dtypes,
+    check_device as _check_device
+)
 from ._flags import get_array_api_strict_flags
 from ._typing import NestedSequence, SupportsBufferProtocol, SupportsDLPack
 
@@ -14,7 +18,7 @@ if TYPE_CHECKING:
     from typing_extensions import TypeIs
 
     # Circular import
-    from ._array_object import Array, Device
+    from ._array_object import Array
 
 
 class Undef(Enum):
@@ -24,10 +28,15 @@ class Undef(Enum):
 _undef = Undef.UNDEF
 
 
-def _check_valid_dtype(dtype: DType | None) -> None:
+def _check_valid_dtype(dtype: DType | None, device: Device | None = None) -> None:
     # Note: Only spelling dtypes as the dtype objects is supported.
-    if dtype not in (None,) + _all_dtypes:
-        raise ValueError(f"dtype must be one of the supported dtypes, got {dtype!r}")
+    if dtype is not None:
+        if dtype not in _all_dtypes:
+            raise ValueError(f"dtype must be one of the supported dtypes, got {dtype!r}")
+
+        if device is not None:
+            if not device_supports_dtype(device, dtype):
+                raise ValueError(f"Device {device!r} does not support dtype={dtype!r}.")
 
 
 def _supports_buffer_protocol(obj: object) -> TypeIs[SupportsBufferProtocol]:
@@ -38,18 +47,6 @@ def _supports_buffer_protocol(obj: object) -> TypeIs[SupportsBufferProtocol]:
     return True
 
 
-def _check_device(device: Device | None) -> None:
-    # _array_object imports in this file are inside the functions to avoid
-    # circular imports
-    from ._array_object import ALL_DEVICES, Device
-
-    if device is not None and not isinstance(device, Device):
-        raise ValueError(f"Unsupported device {device!r}")
-
-    if device is not None and device not in ALL_DEVICES:
-        raise ValueError(f"Unsupported device {device!r}")
-
-
 def asarray(
     obj: Array | complex | NestedSequence[complex] | SupportsBufferProtocol,
     /,
@@ -65,11 +62,12 @@ def asarray(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
+    _check_device(device)
+    _check_valid_dtype(dtype, device)
     _np_dtype = None
     if dtype is not None:
         _np_dtype = dtype._np_dtype
-    _check_device(device)
+
     if isinstance(obj, Array) and device is None:
         device = obj.device
 
@@ -108,6 +106,27 @@ def asarray(
         raise OverflowError("Integer out of bounds for array dtypes")
 
     res = np.array(obj, dtype=_np_dtype, copy=copy)
+
+    # numpy default dtype may differ; if so, adjust the dtype
+    if dtype is None and device is not None:
+        res_dtype = DType(res.dtype)
+        # The dtype selected by Numpy might not be the default dtype
+        # on this device. We thus find the default dtype for the dtype "kind", and
+        # cast to the device-appropriate default.
+        from ._data_type_functions import isdtype
+        if isdtype(res_dtype, "bool"):
+            target_dtype = DType("bool")
+        elif isdtype(res_dtype, "integral"):
+            target_dtype = get_default_dtypes(device)["integral"]
+        elif isdtype(res_dtype, "real floating"):
+            target_dtype = get_default_dtypes(device)["real floating"]
+        elif isdtype(res_dtype, "complex floating"):
+            target_dtype = get_default_dtypes(device)["complex floating"]
+        else:
+            raise ValueError(f"{res_dtype = } not understood.")
+
+        res = res.astype(target_dtype._np_dtype)
+
     return Array._new(res, device=device)
 
 
@@ -127,8 +146,13 @@ def arange(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        if any(isinstance(x, float) for x in (start, stop, step)):
+            dtype = get_default_dtypes(device)["real floating"]
+        else:
+            dtype = get_default_dtypes(device)["integral"]
 
     return Array._new(
         np.arange(start, stop, step, dtype=_np_dtype(dtype)),
@@ -149,8 +173,10 @@ def empty(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        dtype = get_default_dtypes(device)["real floating"]
 
     return Array._new(np.empty(shape, dtype=_np_dtype(dtype)), device=device)
 
@@ -165,10 +191,12 @@ def empty_like(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
     if device is None:
         device = x.device
+    if dtype is None:
+        dtype = x.dtype
+    _check_valid_dtype(dtype, device)
 
     return Array._new(np.empty_like(x._array, dtype=_np_dtype(dtype)), device=device)
 
@@ -189,8 +217,10 @@ def eye(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        dtype = get_default_dtypes(device)["real floating"]
 
     return Array._new(
         np.eye(n_rows, M=n_cols, k=k, dtype=_np_dtype(dtype)), device=device
@@ -212,15 +242,20 @@ def from_dlpack(
         if copy is not _undef:
             raise ValueError("The copy argument to from_dlpack requires at least version 2023.12 of the array API")
 
-    # Going to wait for upstream numpy support
     if device is not _undef:
         _check_device(device)
     else:
         device = None
-    if copy not in [_undef, None]:
-        raise NotImplementedError("The copy argument to from_dlpack is not yet implemented")
+        if hasattr(x, "__dlpack_device__"):
+            from ._devices import _device_from_dlpack_device
 
-    return Array._new(np.from_dlpack(x), device=device)
+            dl_type, dl_id = x.__dlpack_device__()
+            device = _device_from_dlpack_device(dl_type, dl_id)
+    if copy in [_undef, None]:
+        # numpy 1.26 does not have the copy= arg
+        return Array._new(np.from_dlpack(x), device=device)
+
+    return Array._new(np.from_dlpack(x, copy=copy), device=device)
 
 
 def full(
@@ -237,12 +272,22 @@ def full(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
 
     if not isinstance(fill_value, bool | int | float | complex):
         msg = f"Expected Python scalar fill_value, got type {type(fill_value)}"
         raise TypeError(msg)
+
+    if dtype is None:
+        if type(fill_value) == bool:
+            dtype = xp_bool
+        else:
+            kind = {
+                int: "integral", float: "real floating", complex: "complex floating"
+            }[type(fill_value)]
+            dtype = get_default_dtypes(device)[kind]
+
     res = np.full(shape, fill_value, dtype=_np_dtype(dtype))
     if DType(res.dtype) not in _all_dtypes:
         # This will happen if the fill value is not something that NumPy
@@ -266,10 +311,12 @@ def full_like(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
     if device is None:
         device = x.device
+    if dtype is None:
+        dtype = x.dtype
+    _check_valid_dtype(dtype, device)
 
     if not isinstance(fill_value, bool | int | float | complex):
         msg = f"Expected Python scalar fill_value, got type {type(fill_value)}"
@@ -300,8 +347,13 @@ def linspace(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        if isinstance(start, complex) or isinstance(stop, complex):
+            dtype = get_default_dtypes(device)["complex floating"]
+        else:
+            dtype = get_default_dtypes(device)["real floating"]
 
     return Array._new(
         np.linspace(start, stop, num, dtype=_np_dtype(dtype), endpoint=endpoint),
@@ -353,8 +405,10 @@ def ones(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        dtype = get_default_dtypes(device)["real floating"]
 
     return Array._new(np.ones(shape, dtype=_np_dtype(dtype)), device=device)
 
@@ -369,10 +423,12 @@ def ones_like(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
     if device is None:
         device = x.device
+    if dtype is None:
+        dtype = x.dtype
+    _check_valid_dtype(dtype, device)
 
     return Array._new(np.ones_like(x._array, dtype=_np_dtype(dtype)), device=device)
 
@@ -418,8 +474,10 @@ def zeros(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        dtype = get_default_dtypes(device)["real floating"]
 
     return Array._new(np.zeros(shape, dtype=_np_dtype(dtype)), device=device)
 
@@ -434,9 +492,11 @@ def zeros_like(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
     if device is None:
         device = x.device
+    if dtype is None:
+        dtype = x.dtype
+    _check_valid_dtype(dtype, device)
 
     return Array._new(np.zeros_like(x._array, dtype=_np_dtype(dtype)), device=device)