py::object operator()(

const ::tensorstore::dtypes::string_t* x) const noexcept {

return py::reinterpret_steal<py::object>(

PyBytes_FromStringAndSize(x->data(), x->size()));

}

py::object operator()(

const ::tensorstore::dtypes::ustring_t* x) const noexcept {

return py::reinterpret_steal<py::object>(

PyUnicode_FromStringAndSize(x->utf8.data(), x->utf8.size()));

}

py::object operator()(const ::tensorstore::dtypes::json_t* x) const noexcept {

return JsonToPyObject(*x);

}

std::exception_ptr ex;

bool operator()(PyObject** from, ::tensorstore::dtypes::string_t* to,

void*) noexcept {

char* buffer;

Py_ssize_t length;

if (::PyBytes_AsStringAndSize(*from, &buffer, &length) == -1) {

ex = std::make_exception_ptr(py::error_already_set());

return false;

}

to->assign(buffer, length);

return true;

}

bool operator()(PyObject** from, ::tensorstore::dtypes::ustring_t* to,

void*) noexcept {

Py_ssize_t length;

const char* buffer = ::PyUnicode_AsUTF8AndSize(*from, &length);

if (!buffer) {

ex = std::make_exception_ptr(py::error_already_set());

return false;

}

to->utf8.assign(buffer, length);

return true;

}

bool operator()(PyObject** from, ::tensorstore::dtypes::json_t* to,

void*) noexcept {

try {

*to = PyObjectToJson(*from);

return true;

} catch (...) {

ex = std::current_exception();

return false;

}

}

bool is_const) {

Py_ssize_t target_shape_ssize_t[NPY_MAXDIMS];

std::copy(source.shape().begin(), source.shape().end(), target_shape_ssize_t);

auto array_obj = py::reinterpret_steal<py::array>(PyArray_NewFromDescr(

&PyArray_Type, PyArray_DescrFromType(NPY_OBJECT),

static_cast<int>(source.rank()), target_shape_ssize_t,

/*strides=*/nullptr,

/*data=*/nullptr,

/*flags=*/NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_WRITEABLE,

/*obj=*/nullptr));

if (!array_obj) throw py::error_already_set();

Index target_strides[NPY_MAXDIMS];

std::copy_n(array_obj.strides(), source.rank(), target_strides);

if (!internal::IterateOverStridedLayouts<2>(

/*closure=*/{kConvertDataTypeToNumpyObjectArray[static_cast<size_t>(

source.dtype().id())],

nullptr},

/*arg=*/nullptr,

/*shape=*/source.shape(),

{{const_cast<void*>(source.data()),

static_cast<void*>(

py::detail::array_proxy(array_obj.ptr())->data)}},

{{source.byte_strides().data(), target_strides}},

/*constraints=*/skip_repeated_elements,

{{source.dtype().size(), sizeof(PyObject*)}})) {

throw py::error_already_set();

}

if (is_const) {

PyArray_CLEARFLAGS(reinterpret_cast<PyArrayObject*>(array_obj.ptr()),

NPY_ARRAY_WRITEABLE);

}

return std::move(array_obj);

pybind11::array array_obj, DataType dtype) {

if (!dtype.valid()) {

dtype = dtype_v<::tensorstore::dtypes::json_t>;

}

const DimensionIndex rank = array_obj.ndim();

if (rank > kMaxRank) {

throw pybind11::value_error(absl::StrFormat(

"Array of rank %d is not supported by tensorstore", rank));

}

StridedLayout<dynamic_rank(kMaxRank)> array_obj_layout;

array_obj_layout.set_rank(rank);

AssignArrayLayout(array_obj, rank, array_obj_layout.shape().data(),

array_obj_layout.byte_strides().data());

auto array = tensorstore::AllocateArrayLike<void>(

array_obj_layout, skip_repeated_elements, default_init, dtype);

ConvertFromObject converter;

if (!internal::IterateOverStridedLayouts<2>(

/*closure=*/{kConvertDataTypeFromNumpyObjectArray[static_cast<size_t>(

dtype.id())],

&converter},

/*arg=*/nullptr,

/*shape=*/array.shape(),

{{static_cast<void*>(py::detail::array_proxy(array_obj.ptr())->data),

const_cast<void*>(array.data())}},

{{array_obj_layout.byte_strides().data(),

array.byte_strides().data()}},

/*constraints=*/skip_repeated_elements,

{{sizeof(PyObject*), dtype.size()}})) {

std::rethrow_exception(std::move(converter.ex));

}

return array;

Index* shape, Index* byte_strides) {

[[maybe_unused]] const int flags =

py::detail::array_proxy(array_obj.ptr())->flags;

assert(array_obj.ndim() == rank);

assert(flags & NPY_ARRAY_ALIGNED);

std::copy_n(array_obj.shape(), rank, shape);

for (DimensionIndex i = 0; i < rank; ++i) {

if (shape[i] < 0 || shape[i] > kMaxFiniteIndex) {

throw std::out_of_range(

absl::StrFormat("Array shape[%d]=%d is not valid", i, shape[i]));

}

}

std::copy_n(array_obj.strides(), rank, byte_strides);

bool is_const) {

if (value.rank() > NPY_MAXDIMS) {

throw std::out_of_range(

absl::StrFormat("Array of rank %d (which is greater than %d) cannot be "

"converted to NumPy array",

value.rank(), NPY_MAXDIMS));

}

if (const DataTypeId id = value.dtype().id();

id != DataTypeId::custom &&

kConvertDataTypeToNumpyObjectArray[static_cast<size_t>(id)]) {

return GetNumpyObjectArrayImpl(value, is_const);

}

Py_ssize_t shape[NPY_MAXDIMS];

Py_ssize_t strides[NPY_MAXDIMS];

std::copy_n(value.shape().data(), value.rank(), shape);

std::copy_n(value.byte_strides().data(), value.rank(), strides);

int flags = 0;

if (!is_const) {

flags |= NPY_ARRAY_WRITEABLE;

}

auto py_dtype = GetNumpyDtypeOrThrow(value.dtype());

auto obj = py::reinterpret_steal<py::array>(PyArray_NewFromDescr(

/*subtype=*/&PyArray_Type,

/*descr=*/reinterpret_cast<PyArray_Descr*>(py_dtype.release().ptr()),

/*nd=*/static_cast<int>(value.rank()),

/*dims=*/shape,

/*strides=*/strides,

/*data=*/const_cast<void*>(value.data()), flags, nullptr));

if (!obj) throw py::error_already_set();

using Pointer = std::shared_ptr<const void>;

PyArray_SetBaseObject(

reinterpret_cast<PyArrayObject*>(obj.ptr()),

py::capsule(new Pointer(std::move(value.pointer())),

[](void* p) { delete static_cast<Pointer*>(p); })

.release()

.ptr());

return std::move(obj);

// TODO(jbms): Avoid an extra copy

SharedArray<const void> temp_src;

ConvertToArray(src, &temp_src, /*data_type_constraint=*/out.dtype(),

/*min_rank=*/out.rank(), /*max_rank=*/out.rank());

if (!internal::RangesEqual(temp_src.shape(), out.shape())) {

throw py::value_error(absl::StrFormat(

"Cannot copy source array of shape %v"

" to target array of shape %v",

GenericStringify(temp_src.shape()), GenericStringify(out.shape())));

}

CopyArray(temp_src, out);

Py_UCS4 c;

if (PyUnicode_Check(obj.ptr())) {

if (PyUnicode_READY(obj.ptr()) != 0) throw py::error_already_set();

if (PyUnicode_GET_LENGTH(obj.ptr()) != 1) goto invalid;

void* data = PyUnicode_DATA(obj.ptr());

int kind = PyUnicode_KIND(obj.ptr());

c = PyUnicode_READ(kind, data, 0);

} else if (PyBytes_Check(obj.ptr())) {

if (PyBytes_GET_SIZE(obj.ptr()) != 1) goto invalid;

c = PyBytes_AS_STRING(obj.ptr())[0];

} else {

goto invalid;

}

switch (c) {

case 'C':

return ContiguousLayoutOrder::c;

case 'F':

return ContiguousLayoutOrder::fortran;

default:

break;

}

invalid:

throw py::type_error("`order` must be specified as 'C' or 'F'");

SharedArray<void, dynamic_rank>& out,

bool& out_array_is_writable,

DataType data_type_constraint, DimensionIndex min_rank,

DimensionIndex max_rank, bool writable, bool no_throw,

std::optional<bool> copy) {

// Determine the NumPy data type corresponding to `data_type_constraint`.

pybind11::dtype dtype_handle =

data_type_constraint.valid()

? GetNumpyDtypeOrThrow(data_type_constraint)

: pybind11::reinterpret_steal<pybind11::dtype>(pybind11::handle());

int flags = NPY_ARRAY_ALIGNED;

if (writable) {

flags |= NPY_ARRAY_WRITEABLE;

}

if (copy == true) {

flags |= NPY_ARRAY_ENSURECOPY;

} else if (copy == false) {

flags |= NPY_ARRAY_ENSURENOCOPY;

}

// Convert `src` to a NumPy array.

auto obj = pybind11::reinterpret_steal<pybind11::array>(PyArray_FromAny(

src.ptr(), reinterpret_cast<PyArray_Descr*>(dtype_handle.release().ptr()),

min_rank == dynamic_rank ? 0 : min_rank,

max_rank == dynamic_rank ? 0 : max_rank, flags, nullptr));

const auto try_convert = [&] {

if (!obj) {

if (no_throw) {

PyErr_Clear();

return false;

}

throw pybind11::error_already_set();

}

const int type_num =

pybind11::detail::array_descriptor_proxy(obj.dtype().ptr())->type_num;

if (copy == false && type_num == NPY_OBJECT) {

if (no_throw) return false;

throw pybind11::value_error(

"NumPy object arrays cannot be converted without copying");

}

// PyArray_FromAny does not handle rank constraints of 0, so we need to

// check them separately.

if (max_rank == 0 && obj.ndim() != 0) {

if (data_type_constraint != dtype_v<::tensorstore::dtypes::json_t>) {

if (no_throw) return false;

throw pybind11::value_error(absl::StrFormat(

"Expected array of rank 0, but received array of rank %d",

obj.ndim()));

}

// For json data type, the user may have specified a Python value like

// `[1, 2, 3]` which is intended to be interpreted as a single JSON value

// (i.e. rank-0 array). Attempt a conversion directly from the

// user-specified value.

out = MakeScalarArray(PyObjectToJson(src));

out_array_is_writable = true;

return true;

}

if (type_num == NPY_OBJECT) {

// Arrays of Python objects require copying.

out = ArrayFromNumpyObjectArray(std::move(obj), data_type_constraint);

out_array_is_writable = true;

return true;

}

out_array_is_writable = static_cast<bool>(

PyArray_FLAGS(reinterpret_cast<PyArrayObject*>(obj.ptr())) &

NPY_ARRAY_WRITEABLE);

out = UncheckedArrayFromNumpy<void>(std::move(obj));

return true;

};

if (no_throw) {

try {

return try_convert();

} catch (...) {

return false;

}

}

return try_convert();