Coords¤

def unpack_size(N: int | tuple[int, int]) -> tuple[int, int]:
    if isinstance(N, tuple):
        Nx, Ny = N
        return int(Nx), int(Ny)
    return int(N), int(N)

def unpack_scale(d: float | tuple) -> tuple[float, float]:
    if isinstance(d, tuple):
        dx, dy = d
        return float(dx), float(dy)
    val = float(d)
    return val, val

def unpack_coords(coords: Array | tuple) -> tuple[Array, Array]:
    # Avoid isinstance(coords, Array) fragility: just check "ndim"
    if hasattr(coords, "ndim"):
        if coords.ndim != 1:
            raise ValueError(
                f"unpack_coords: Array coords must be 1D, got shape={coords.shape}."
            )
        return coords, coords
    x, y = coords
    return x, y

def unpack_coord_spec(spec: Array | tuple) -> tuple[Array, Array]:
    # Case: explicit array -> symmetric x=y
    if hasattr(spec, "ndim"):
        return unpack_coords(spec)

    if isinstance(spec, tuple) and len(spec) == 2:
        a, b = spec

        # Uniform spec: (N, d) or ((Nx, Ny), (dx, dy))
        if _is_size_like(a) and _is_scale_like(b):
            Nx, Ny = unpack_size(a)
            dx, dy = unpack_scale(b)
            x = dlu.nd_coords(Nx, dx)
            y = dlu.nd_coords(Ny, dy)
            return x, y

        # Explicit (x, y)
        if not _is_size_like(a) and not _is_scale_like(b):
            return unpack_coords(spec)

    raise TypeError(f"unpack_coord_spec: unsupported spec {type(spec)} value={spec}")