cdef:

unique_ptr[CFunctionContext] ctx

def __cinit__(self):

cdef void init(self, const shared_ptr[CArray]& sp_array):

self.sp_array = sp_array

self.ap = sp_array.get()

"""

cdef:

CCastOptions options

shared_ptr[CArray] result

DataType type

type = _ensure_type(target_type)

if not safe:

options.allow_int_overflow = 1

with nogil:

check_status(Cast(_context(), self.ap[0], type.sp_type,

options, &result))

"""

return array(obj, mask=mask, type=type, memory_pool=memory_pool,

from pyarrow.formatting import array_format

type_format = object.__repr__(self)

values = array_format(self, window=10)

if self.sp_array.get():

return self.sp_array.get().length()

else:

cdef Py_ssize_t n = len(self)

if PySlice_Check(key):

return _normalize_slice(self, key)

while key < 0:

key += len(self)

cdef void init(self, const shared_ptr[CTensor]& sp_tensor):

self.sp_tensor = sp_tensor

self.tp = sp_tensor.get()

return """<pyarrow.Tensor>

cdef shared_ptr[CTensor] ctensor

with nogil:

check_status(NdarrayToTensor(c_default_memory_pool(), obj,

&ctensor))

"""

cdef:

PyObject* out

with nogil:

check_status(TensorToNdarray(deref(self.tp), self, &out))

"""

cdef size_t i

py_shape = []

for i in range(self.tp.shape().size()):

py_shape.append(self.tp.shape()[i])

cdef size_t i

py_strides = []

for i in range(self.tp.strides().size()):

py_strides.append(self.tp.strides()[i])

@staticmethod

def from_arrays(offsets, values, MemoryPool pool=None):

"""

cdef:

Array _offsets, _values

shared_ptr[CArray] out

cdef CMemoryPool* cpool = maybe_unbox_memory_pool(pool)

_offsets = asarray(offsets, type='int32')

_values = asarray(values)

with nogil:

check_status(CListArray.FromArrays(_offsets.ap[0], _values.ap[0],

cpool, &out))

cdef getitem(self, int64_t i):

cdef Array dictionary = self.dictionary

index = self.indices[i]

if index is NA:

return index

else:

return box_scalar(dictionary.type, dictionary.sp_array,

cdef CDictionaryArray* darr = <CDictionaryArray*>(self.ap)

if self._dictionary is None:

self._dictionary = pyarrow_wrap_array(darr.dictionary())

cdef CDictionaryArray* darr = <CDictionaryArray*>(self.ap)

if self._indices is None:

self._indices = pyarrow_wrap_array(darr.indices())

MemoryPool memory_pool=None):

"""

cdef:

Array arrow_indices, arrow_dictionary

DictionaryArray result

shared_ptr[CDataType] c_type

shared_ptr[CArray] c_result

if isinstance(indices, Array):

if mask is not None:

raise NotImplementedError(

"mask not implemented with Arrow array inputs yet")

arrow_indices = indices

else:

if mask is None:

mask = indices == -1

else:

mask = mask | (indices == -1)

arrow_indices = Array.from_pandas(indices, mask=mask,

memory_pool=memory_pool)

if isinstance(dictionary, Array):

arrow_dictionary = dictionary

else:

arrow_dictionary = Array.from_pandas(dictionary,

memory_pool=memory_pool)

if not isinstance(arrow_indices, IntegerArray):

raise ValueError('Indices must be integer type')

cdef c_bool c_ordered = ordered

c_type.reset(new CDictionaryType(arrow_indices.type.sp_type,

arrow_dictionary.sp_array, c_ordered))

c_result.reset(new CDictionaryArray(c_type, arrow_indices.sp_array))

result = DictionaryArray()

result.init(c_result)

@staticmethod

def from_arrays(field_names, arrays):

cdef:

Array array

shared_ptr[CArray] c_array

vector[shared_ptr[CArray]] c_arrays

shared_ptr[CArray] c_result

ssize_t num_arrays

ssize_t length

ssize_t i

num_arrays = len(arrays)

if num_arrays == 0:

raise ValueError("arrays list is empty")

length = len(arrays[0])

c_arrays.resize(num_arrays)

for i in range(num_arrays):

array = arrays[i]

if len(array) != length:

raise ValueError("All arrays must have the same length")

c_arrays[i] = array.sp_array

cdef DataType struct_type = struct([

field(name, array.type)

for name, array in

zip(field_names, arrays)

])

c_result.reset(new CStructArray(struct_type.sp_type, length, c_arrays))

result = StructArray()

result.init(c_result)