cobra-array 0.1.1__tar.gz → 0.1.2__tar.gz

{cobra_array-0.1.1/src/cobra_array.egg-info → cobra_array-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobra-array
-Version: 0.1.1
+Version: 0.1.2
 Summary: A backend-agnostic array utility library that unifies array conversion, context control, and cross-library operations across `NumPy`/`PyTorch`-style ecosystems.
 Author-email: Zhen Tian <zhen.tian.cs@gmail.com>
 Project-URL: Homepage, https://github.com/tinchen777/cobra-array.git
@@ -71,14 +71,11 @@ pip install cobra-array
 
     data = [[1, 2], [3, 4]]
 
-    arr_np = to_numpy(data, dtype=np.float32)
-    print(type(arr_np), arr_np.dtype)  # numpy.ndarray float32
+    arr_np = to_numpy(data, dtype=np.float32)  # numpy.ndarray float32
 
     arr_torch = to_tensor(data, device="cpu")
-    print(type(arr_torch), arr_torch.device)
 
-    back_to_list = to_list(arr_np)
-    print(back_to_list)  # [[1.0, 2.0], [3.0, 4.0]]
+    back_to_list = to_list(arr_np)  # [[1.0, 2.0], [3.0, 4.0]]
     ```
 
 - Context-based conversion:
@@ -91,8 +88,6 @@ pip install cobra-array
         x = as_context([1, 2, 3])
         y = as_context(np.array([4, 5]))
         spec = context_spec()
-        print(spec.cxp.xp_name, spec.dtype, spec.device)
-        print(x, y)
     ```
 
 - Auto-unify function arguments:
@@ -107,7 +102,6 @@ pip install cobra-array
         return c.mean()
 
     out = add_and_mean(np.array([1, 2, 3]), [4, 5, 6])
-    print(out)
     ```
 
 - Default backend strategy:
@@ -116,10 +110,8 @@ pip install cobra-array
     from cobra_array.default import as_default, default_spec
 
     spec = default_spec()
-    print(spec.cxp.xp_name, spec.dtype, spec.device)
 
     x = as_default([1, 2, 3], unify_dtype=True, unify_device=True)
-    print(x, x.dtype)
     ```
 
 ## Requirements

{cobra_array-0.1.1 → cobra_array-0.1.2}/README.md

@@ -46,14 +46,11 @@ pip install cobra-array
 
     data = [[1, 2], [3, 4]]
 
-    arr_np = to_numpy(data, dtype=np.float32)
-    print(type(arr_np), arr_np.dtype)  # numpy.ndarray float32
+    arr_np = to_numpy(data, dtype=np.float32)  # numpy.ndarray float32
 
     arr_torch = to_tensor(data, device="cpu")
-    print(type(arr_torch), arr_torch.device)
 
-    back_to_list = to_list(arr_np)
-    print(back_to_list)  # [[1.0, 2.0], [3.0, 4.0]]
+    back_to_list = to_list(arr_np)  # [[1.0, 2.0], [3.0, 4.0]]
     ```
 
 - Context-based conversion:
@@ -66,8 +63,6 @@ pip install cobra-array
         x = as_context([1, 2, 3])
         y = as_context(np.array([4, 5]))
         spec = context_spec()
-        print(spec.cxp.xp_name, spec.dtype, spec.device)
-        print(x, y)
     ```
 
 - Auto-unify function arguments:
@@ -82,7 +77,6 @@ pip install cobra-array
         return c.mean()
 
     out = add_and_mean(np.array([1, 2, 3]), [4, 5, 6])
-    print(out)
     ```
 
 - Default backend strategy:
@@ -91,10 +85,8 @@ pip install cobra-array
     from cobra_array.default import as_default, default_spec
 
     spec = default_spec()
-    print(spec.cxp.xp_name, spec.dtype, spec.device)
 
     x = as_default([1, 2, 3], unify_dtype=True, unify_device=True)
-    print(x, x.dtype)
     ```
 
 ## Requirements

{cobra_array-0.1.1 → cobra_array-0.1.2}/src/cobra_array/__init__.py

@@ -25,23 +25,20 @@ Functions
 
 Examples
 --------
-Basic conversions::
+- Basic conversions::
 
     import numpy as np
     from cobra_array.convert import to_numpy, to_tensor, to_list
 
     data = [[1, 2], [3, 4]]
 
-    arr_np = to_numpy(data, dtype=np.float32)
-    print(type(arr_np), arr_np.dtype)  # numpy.ndarray float32
+    arr_np = to_numpy(data, dtype=np.float32)  # numpy.ndarray float32
 
     arr_torch = to_tensor(data, device="cpu")
-    print(type(arr_torch), arr_torch.device)
 
-    back_to_list = to_list(arr_np)
-    print(back_to_list)  # [[1.0, 2.0], [3.0, 4.0]]
+    back_to_list = to_list(arr_np)  # [[1.0, 2.0], [3.0, 4.0]]
 
-Context-based conversion::
+- Context-based conversion::
 
     import numpy as np
     from cobra_array import array_context, as_context, context_spec
@@ -50,10 +47,8 @@ Context-based conversion::
         x = as_context([1, 2, 3])
         y = as_context(np.array([4, 5]))
         spec = context_spec()
-        print(spec.cxp.xp_name, spec.dtype, spec.device)
-        print(x, y)
 
-Auto-unify function arguments::
+- Auto-unify function arguments::
 
     import numpy as np
     from cobra_array import unify_args
@@ -64,17 +59,14 @@ Auto-unify function arguments::
         return c.mean()
 
     out = add_and_mean(np.array([1, 2, 3]), [4, 5, 6])
-    print(out)
 
-Default backend strategy::
+- Default backend strategy::
 
     from cobra_array.default import as_default, default_spec
 
     spec = default_spec()
-    print(spec.cxp.xp_name, spec.dtype, spec.device)
 
     x = as_default([1, 2, 3], unify_dtype=True, unify_device=True)
-    print(x, x.dtype)
 """
 
 from ._core import (
@@ -91,7 +83,7 @@ from ._utils import (
 )
 
 __author__ = "Zhen Tian"
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 
 __all__ = [
     "array_spec",

{cobra_array-0.1.1 → cobra_array-0.1.2}/src/cobra_array/_core.py

@@ -85,6 +85,32 @@ def array_spec(
             If `ref` is not `None`, a string, or an integer.
         NotArrayAPIObjectError
             If the reference array determined by `ref` is not an array API compatible array object.
+
+    Examples
+    --------
+    Infer namespace from positional arrays:
+
+    >>> import numpy as np
+    >>> spec = array_spec(np.asarray([1, 2]), np.asarray([3, 4]))
+    >>> spec.cxp.xp_name
+    'NumPy'
+    >>> spec.dtype is None and spec.device is None
+    True
+
+    Use a keyword argument as reference to carry dtype and device:
+
+    >>> ref_arr = np.asarray([1, 2], dtype=np.float32)
+    >>> spec = array_spec(kw_arrays={"x": ref_arr}, ref="x")
+    >>> str(spec.dtype)
+    'float32'
+    >>> str(spec.device)
+    'cpu'
+
+    Filter non-array-like inputs when selecting reference by index:
+
+    >>> spec = array_spec("skip", np.asarray([1, 2]), ref=0, filter_arraylike=True)
+    >>> spec.cxp.xp_name
+    'NumPy'
     """
     kw_arrays = kw_arrays or {}
 
@@ -240,6 +266,12 @@ def as_context(
     Raises
     ------
         Refer to :func:`convert.as_array`, :func:`context_spec` for possible exceptions.
+
+    Examples
+    --------
+    >>> from cobra_array import as_context
+    >>> as_context([1, 2, 3])
+    PyTorch_Array(tensor([1., 2., 3.], dtype=torch.float64))
     """
     spec = context_spec()
     return wrap_arraylike(as_array(
@@ -254,6 +286,40 @@ def as_context(
 class array_context:
     """
     **Context Manager** to set the context `compatibility namespace`, `dtype` and `device` for the enclosed block of code.
+
+    Examples
+    --------
+    Set a temporary context explicitly:
+
+    >>> from cobra_array import array_context
+    >>> with array_context(xp="numpy", dtype=None, device="cpu") as spec:
+    ...     spec.cxp.xp_name
+    'NumPy'
+
+    Convert data in the active context:
+
+    >>> with array_context(xp="numpy", dtype=None, device="cpu"):
+    ...     as_context([1, 2, 3], unify_dtype=False)
+    NumPy_Array([1 2 3])
+
+    Build a context from :class:`ArraySpec`:
+
+    >>> import numpy as np
+    >>> spec = array_spec(np.asarray([1, 2], dtype=np.float32), ref=0)
+    >>> with array_context.from_array_spec(spec) as cur:
+    ...     str(cur.dtype)
+    'float32'
+
+    Nested contexts override temporarily and then restore outer context:
+
+    >>> from cobra_array import context_spec
+    >>> with array_context(xp="numpy", dtype=None, device="cpu"):
+    ...     before = context_spec().dtype
+    ...     with array_context(dtype=float):
+    ...         middle = context_spec().dtype
+    ...     after = context_spec().dtype
+    ...     (before is None, middle is float, after is None)
+    (True, True, True)
     """
     @classmethod
     def from_array_spec(cls, arr_spec: ArraySpec, /):
@@ -309,7 +375,7 @@ class array_context:
 
 def unify_args(
     ref: Optional[Union[str, int]] = 0,
-    /,
+    /, *,
     filter_arraylike: bool = True,
     api_version: Optional[str] = None,
     use_compat: Optional[bool] = None,
@@ -353,6 +419,18 @@ def unify_args(
     Raises
     ------
         Refer to :func:`default.default_spec`, :func:`as_context` for possible exceptions.
+
+    Examples
+    --------
+    Use `unify_args` as a decorator to normalize array arguments before the function body runs:
+
+    >>> import numpy as np
+    >>> from cobra_array import unify_args
+    >>> @unify_args(ref=0, unify_dtype=False, unify_device=False)
+    ... def add(x, y):
+    ...     return x + y
+    >>> add(np.asarray([1, 2]), y=np.asarray([3, 4]))
+    NumPy_Array([4 6])
     """
     def decorator(func):
         @wraps(func)

{cobra_array-0.1.1 → cobra_array-0.1.2}/src/cobra_array/_utils.py

@@ -43,7 +43,7 @@ def array_namespace_alias(xp: object) -> str:
     Raises
     ------
         UnsupportedNameSpaceError
-            If the input object is not a supported namespace.
+            If the input object is not a supported `array namespace`.
     """
     if isinstance(xp, ModuleType):
         if api.is_numpy_namespace(xp):

{cobra_array-0.1.1 → cobra_array-0.1.2}/src/cobra_array/array_api.py

@@ -15,6 +15,24 @@ Attributes
 Functions
 ---------
 - :func:`resolve_device`: Get the device string from an object or a device specification string, and check if it is compatible with the specified `array namespace` if provided.
+
+Examples
+--------
+- Basic usage::
+
+    from cobra_array.array_api import resolve_device, torch_xp, numpy_xp
+
+    r = resolve_device("cpu")        # "cpu"
+    r = resolve_device("cuda:0")     # "cuda:0"
+
+    if numpy_xp is not None:
+        r = resolve_device("cpu", xp="numpy")
+
+    if torch_xp is not None:
+        r = resolve_device("cpu", xp="torch")
+
+    if torch_xp is not None:
+        r = resolve_device("cpu", xp=torch_xp)
 """
 
 from __future__ import annotations
@@ -61,7 +79,7 @@ def resolve_device(
         obj : object
             The input object or device specification string to extract the device information from.
 
-        xp : Optional[Union[Namespace, CompatNamespace, ArrayLibraryName]], default is `None`
+        xp : Optional[Union[Any, ArrayLibraryName]], default is `None`
             The `array namespace` to check the device compatibility against.
             - `None`: No compatibility check will be performed.
 
@@ -80,6 +98,54 @@ def resolve_device(
             If the extracted device is not compatible with the specified `array namespace`.
         CUDAUnavailableError
             If a CUDA device is specified but CUDA is not available for `PyTorch`.
+
+    Examples
+    --------
+    Basic parsing and normalization:
+
+    >>> resolve_device("cpu")
+    'cpu'
+    >>> resolve_device(" CUDA:0 ")
+    'cuda:0'
+    >>> resolve_device(None)
+    None
+
+    Namespace compatibility checks:
+
+    >>> resolve_device("cpu")
+    'cpu'
+    >>> resolve_device("cpu", xp="numpy")
+    'cpu'
+    >>> resolve_device("cpu", xp="torch")
+    'cpu'
+
+    Unsupported device for NumPy:
+
+    >>> resolve_device("cuda:0", xp="numpy")
+    Traceback (most recent call last):
+        ...
+    cobra_array.exceptions.DeviceNotSupportedError: ...
+
+    Unsupported device type for PyTorch:
+
+    >>> resolve_device("quantum", xp="torch")
+    Traceback (most recent call last):
+        ...
+    cobra_array.exceptions.DeviceNotSupportedError: ...
+
+    CUDA path for PyTorch (works with or without CUDA runtime):
+
+    >>> from cobra_array.array_api import CUDA_AVAILABLE
+    >>> result = None
+    >>> if not CUDA_AVAILABLE:
+    ...     try:
+    ...         resolve_device("cuda:0", xp="torch")
+    ...     except CUDAUnavailableError:
+    ...         result = "CUDAUnavailableError"
+    ... else:
+    ...     result = resolve_device("cuda:0", xp="torch")
+    >>> result in {"cuda:0", "CUDAUnavailableError"}
+    True
     """
     # source
     if obj is None:

{cobra_array-0.1.1 → cobra_array-0.1.2}/src/cobra_array/compat/__init__.py

@@ -10,6 +10,23 @@ Classes
 -------
 - :class:`CompatArray`: A backend-agnostic array abstraction compliant with the `Python Array API standard`.
 - :class:`CompatNamespace`: A wrapper around an `array namespace` providing a unified, backend-agnostic functional interface.
+
+Examples
+--------
+- Basic usage::
+
+    import numpy as np
+    from cobra_array.compat import CompatArray, CompatNamespace, wrap_arraylike, unwrap
+
+    cxp = CompatNamespace(np)
+    a = CompatArray(np.asarray([1, 2, 3]))
+    b = cxp.asarray([10, 20, 30])
+
+    r = (a + b).to_list()        # [11, 22, 33]
+    r = cxp.add(a, b).to_list()  # [11, 22, 33]
+
+    wrapped = wrap_arraylike(np.asarray([4, 5]))
+    unwrap(wrapped).tolist()  # [4, 5]
 """
 
 from ._array import (CompatArray, wrap_arraylike, unwrap)

{cobra_array-0.1.1 → cobra_array-0.1.2}/src/cobra_array/compat/_array.py

@@ -26,6 +26,61 @@ class CompatArray(Compat):
     - All operations follow the semantics defined by the `Python Array API standard`.
     - Methods correspond directly to standard functions, but are exposed in an object-oriented form.
     - All methods guarantee that any array-like objects in the returned value are automatically wrapped as :class:`CompatArray`. This applies recursively to arrays contained in Python containers (e.g., `tuple`, `list`, `dict`). Non-array objects remain unchanged.
+
+    Examples
+    --------
+    Create a :class:`CompatArray` from a backend array object:
+
+    >>> xp = to_xp("numpy")
+    >>> a = CompatArray(xp.asarray([1, 2, 3]))
+    >>> a
+    NumPy_Array([1 2 3])
+    >>> a.to_list()
+    [1, 2, 3]
+    >>> a.shape
+    (3,)
+    >>> a.xp_name
+    'NumPy'
+
+    Convert Python data with an explicit backend:
+
+    >>> b = CompatArray.from_other([10, 20], xp="numpy")
+    >>> isinstance(b, CompatArray)
+    True
+    >>> b.to_tensor()
+    tensor([10, 20])
+
+    Re-wrapping behavior for existing :class:`CompatArray`:
+
+    >>> CompatArray(b) is b
+    True
+    >>> CompatArray(b, copy=True) is b
+    False
+
+    Call elementwise functions directly:
+
+    >>> x = CompatArray.from_other([1, 2, 3], xp="numpy")
+    >>> y = CompatArray.from_other([10, 20, 30], xp="numpy")
+    >>> x.add(y)
+    NumPy_Array([11 22 33])
+    >>> x.multiply(2)
+    NumPy_Array([2 4 6])
+
+    Use Python operators:
+
+    >>> x + y
+    NumPy_Array([11 22 33])
+    >>> y - x
+    NumPy_Array([ 9 18 27])
+    >>> x * 2
+    NumPy_Array([2 4 6])
+
+    Invalid input raises an exception:
+
+    >>> CompatArray("not-array")
+    Traceback (most recent call last):
+        ...
+    cobra_array.exceptions.NotArrayAPIObjectError: ...
     """
     _arr = None
     _cxp = None

{cobra_array-0.1.1 → cobra_array-0.1.2}/src/cobra_array/compat/_namespace.py

@@ -23,6 +23,31 @@ class CompatNamespace(Compat):
     - Functions correspond directly to those defined in the underlying `array namespace`, following the `Python Array API standard`.
     - This namespace complements :class:`CompatArray` by providing a functional interface for operations that are not naturally expressed as methods.
     - All functions guarantee that any array-like objects in the returned value are automatically wrapped as :class:`CompatArray`. This conversion is applied recursively to arrays contained in Python containers (e.g., `tuple`, `list`, `dict`). Non-array objects remain unchanged.
+
+    Examples
+    --------
+    Create a compatibility namespace from a backend namespace:
+
+    >>> import numpy as np
+    >>> cxp = CompatNamespace(np)
+    >>> cxp.xp_name
+    'NumPy'
+
+    Create arrays and call namespace functions:
+
+    >>> a = cxp.asarray([1, 2, 3])
+    >>> b = cxp.asarray([10, 20, 30])
+    >>> a
+    NumPy_Array([1 2 3])
+    >>> cxp.add(a, b).to_list()
+    [11, 22, 33]
+
+    Missing attributes raise an exception:
+
+    >>> cxp.this_attr_does_not_exist
+    Traceback (most recent call last):
+        ...
+    AttributeError: ...
     """
     def __new__(cls, xp, /):
         if isinstance(xp, CompatNamespace):

{cobra_array-0.1.1 → cobra_array-0.1.2}/src/cobra_array/convert.py

@@ -12,6 +12,24 @@ Functions
 - :func:`to_list`: Convert an object to a built-in `list`.
 - :func:`to_array_namespace` or :func:`to_xp`: Convert an array library name to a `array namespace` or return the `array namespace` directly if is a supported namespace.
 - :func:`as_array`: Convert an object to an array in the specified `array namespace`.
+
+Examples
+--------
+- Basic usage::
+
+    import numpy as np
+    from cobra_array.convert import to_numpy, to_tensor, to_list, to_xp, as_array
+
+    r = to_numpy([1, 2, 3])            # array([1, 2, 3])
+    r = to_list(np.asarray([1, 2, 3]))  # [1, 2, 3]
+    r = to_xp("numpy")                # NumPy namespace
+    r = as_array([1, 2, 3], "numpy")   # NumPy array
+
+- When PyTorch is available, the same helpers can be used with the torch namespace::
+
+    from cobra_array.convert import as_array
+
+    r = as_array([1, 2, 3], "torch")   # PyTorch tensor
 """
 
 from collections import abc
@@ -304,6 +322,41 @@ def as_array(obj, xp, /, *, dtype=None, device=None, copy=False, arraylike_only=
             If an unsupported `array namespace` is specified.
         ArrayConversionError
             If an error occurs during array conversion in the specified `array namespace`.
+
+    Examples
+    --------
+    Convert to NumPy namespace (when available):
+
+    >>> from cobra_array.array_api import numpy_xp
+    >>> if numpy_xp is not None:
+    ...     as_array([1, 2, 3], "numpy")
+    array([1, 2, 3])
+    >>> if numpy_xp is not None:
+    ...     as_array([1, 2, 3], numpy_xp)
+    array([1, 2, 3])
+
+    Convert to PyTorch namespace (when available):
+
+    >>> from cobra_array.array_api import torch_xp
+    >>> if torch_xp is not None:
+    ...     as_array([1, 2, 3], "torch")
+    tensor([1, 2, 3])
+    >>> if torch_xp is not None:
+    ...     as_array([1, 2, 3], torch_xp)
+    tensor([1, 2, 3])
+
+    Pass through non-array-like objects with `arraylike_only=True`:
+
+    >>> marker = object()
+    >>> as_array(marker, "numpy", arraylike_only=True) is marker
+    True
+
+    Unsupported namespace name raises an error:
+
+    >>> as_array([1, 2, 3], "unknown")
+    Traceback (most recent call last):
+        ...
+    cobra_array.exceptions.UnsupportedArrayLibraryNameError: ...
     """
     if arraylike_only and not api.is_array_api_obj(obj):
         return obj

{cobra_array-0.1.1 → cobra_array-0.1.2}/src/cobra_array/default.py

@@ -15,6 +15,19 @@ Functions
 ---------
 - :func:`default_spec`: Get the default array specification.
 - :func:`as_default`: Convert an array-like object to a :class:`CompatArray` array in the default context.
+
+Examples
+--------
+- Basic usage::
+
+    from cobra_array.default import default_spec, as_default
+
+    spec = default_spec()
+    spec.cxp.xp_name   # "PyTorch" or "NumPy"
+    spec.dtype         # default dtype, e.g. float
+    spec.device        # default device, e.g. "cpu"
+
+    arr = as_default([1, 2, 3])  # PyTorch_Array(tensor([1., 2., 3.], dtype=torch.float64)) or CompatArray([1. 2. 3.])
 """
 
 from __future__ import annotations
@@ -53,7 +66,7 @@ class ArraySpec(NamedTuple):
 
 
 # get defaults
-DEFAULT_DTYPE = float
+DEFAULT_DTYPE = None
 DEFAULT_DEVICE = "cpu"
 NUMPY_COMPAT_NAMESPACE = CompatNamespace(numpy_xp) if numpy_xp is not None else None
 TORCH_COMPAT_NAMESPACE = CompatNamespace(torch_xp) if torch_xp is not None else None
@@ -131,6 +144,12 @@ def as_default(
     Raises
     ------
         Refer to :func:`convert.as_array`, :func:`default.default_spec` for possible exceptions.
+
+    Examples
+    --------
+    >>> from cobra_array.default import as_default
+    >>> as_default([1, 2, 3])
+    PyTorch_Array(tensor([1., 2., 3.], dtype=torch.float64))
     """
     spec = default_spec()
     return wrap_arraylike(as_array(

{cobra_array-0.1.1 → cobra_array-0.1.2/src/cobra_array.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobra-array
-Version: 0.1.1
+Version: 0.1.2
 Summary: A backend-agnostic array utility library that unifies array conversion, context control, and cross-library operations across `NumPy`/`PyTorch`-style ecosystems.
 Author-email: Zhen Tian <zhen.tian.cs@gmail.com>
 Project-URL: Homepage, https://github.com/tinchen777/cobra-array.git
@@ -71,14 +71,11 @@ pip install cobra-array
 
     data = [[1, 2], [3, 4]]
 
-    arr_np = to_numpy(data, dtype=np.float32)
-    print(type(arr_np), arr_np.dtype)  # numpy.ndarray float32
+    arr_np = to_numpy(data, dtype=np.float32)  # numpy.ndarray float32
 
     arr_torch = to_tensor(data, device="cpu")
-    print(type(arr_torch), arr_torch.device)
 
-    back_to_list = to_list(arr_np)
-    print(back_to_list)  # [[1.0, 2.0], [3.0, 4.0]]
+    back_to_list = to_list(arr_np)  # [[1.0, 2.0], [3.0, 4.0]]
     ```
 
 - Context-based conversion:
@@ -91,8 +88,6 @@ pip install cobra-array
         x = as_context([1, 2, 3])
         y = as_context(np.array([4, 5]))
         spec = context_spec()
-        print(spec.cxp.xp_name, spec.dtype, spec.device)
-        print(x, y)
     ```
 
 - Auto-unify function arguments:
@@ -107,7 +102,6 @@ pip install cobra-array
         return c.mean()
 
     out = add_and_mean(np.array([1, 2, 3]), [4, 5, 6])
-    print(out)
     ```
 
 - Default backend strategy:
@@ -116,10 +110,8 @@ pip install cobra-array
     from cobra_array.default import as_default, default_spec
 
     spec = default_spec()
-    print(spec.cxp.xp_name, spec.dtype, spec.device)
 
     x = as_default([1, 2, 3], unify_dtype=True, unify_device=True)
-    print(x, x.dtype)
     ```
 
 ## Requirements

{cobra_array-0.1.1 → cobra_array-0.1.2}/tests/test_default.py

@@ -19,7 +19,7 @@ def test_default_spec_returns_valid_defaults():
     spec = default_spec()
     assert isinstance(spec, ArraySpec)
     assert isinstance(spec.cxp, CompatNamespace)
-    assert spec.dtype is float
+    assert spec.dtype is None
     assert spec.device == "cpu"