FM / python

/usr/local/lib64/python3.6/site-packages/pyarrow/include/arrow/python/

/usr/local/lib64/python3.6/site-packages/pyarrow/include/arrow/python

Name	Size	Mode	Actions
api.h	1222	0644	edit dl rm
arrow_to_pandas.h	4450	0644	edit dl rm
benchmark.h	1192	0644	edit dl rm
common.h	11067	0644	edit dl rm
datetime.h	7251	0644	edit dl rm
decimal.h	4726	0644	edit dl rm
deserialize.h	3889	0644	edit dl rm
extension_type.h	3155	0644	edit dl rm
filesystem.h	4955	0644	edit dl rm
flight.h	14525	0644	edit dl rm
helpers.h	5441	0644	edit dl rm
inference.h	2051	0644	edit dl rm
init.h	948	0644	edit dl rm
io.h	3552	0644	edit dl rm
ipc.h	1664	0644	edit dl rm
iterators.h	7193	0644	edit dl rm
numpy_convert.h	4780	0644	edit dl rm
numpy_interop.h	3124	0644	edit dl rm
numpy_to_arrow.h	2760	0644	edit dl rm
pch.h	1129	0644	edit dl rm
platform.h	1260	0644	edit dl rm
pyarrow.h	2524	0644	edit dl rm
pyarrow_api.h	20107	0644	edit dl rm
pyarrow_lib.h	4905	0644	edit dl rm
python_to_arrow.h	2521	0644	edit dl rm
serialize.h	4395	0644	edit dl rm
type_traits.h	10093	0644	edit dl rm
visibility.h	1332	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/pyarrow/include/arrow/python/deserialize.h (3889B)

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#pragma once

#include <cstdint>
#include <memory>
#include <vector>

#include "arrow/python/serialize.h"
#include "arrow/python/visibility.h"
#include "arrow/status.h"

namespace arrow {

class RecordBatch;
class Tensor;

namespace io {

class RandomAccessFile;

}  // namespace io

namespace py {

struct ARROW_PYTHON_EXPORT SparseTensorCounts {
  int coo;
  int csr;
  int csc;
  int csf;
  int ndim_csf;

int num_total_tensors() const { return coo + csr + csc + csf; }
  int num_total_buffers() const {
    return coo * 3 + csr * 4 + csc * 4 + 2 * ndim_csf + csf;
  }
};

/// \brief Read serialized Python sequence from file interface using Arrow IPC
/// \param[in] src a RandomAccessFile
/// \param[out] out the reconstructed data
/// \return Status
ARROW_PYTHON_EXPORT
Status ReadSerializedObject(io::RandomAccessFile* src, SerializedPyObject* out);

/// \brief Reconstruct SerializedPyObject from representation produced by
/// SerializedPyObject::GetComponents.
///
/// \param[in] num_tensors number of tensors in the object
/// \param[in] num_sparse_tensors number of sparse tensors in the object
/// \param[in] num_ndarrays number of numpy Ndarrays in the object
/// \param[in] num_buffers number of buffers in the object
/// \param[in] data a list containing pyarrow.Buffer instances. It must be 1 +
/// num_tensors * 2 + num_coo_tensors * 3 + num_csr_tensors * 4 + num_csc_tensors * 4 +
/// num_csf_tensors * (2 * ndim_csf + 3) + num_buffers in length
/// \param[out] out the reconstructed object
/// \return Status
ARROW_PYTHON_EXPORT
Status GetSerializedFromComponents(int num_tensors,
                                   const SparseTensorCounts& num_sparse_tensors,
                                   int num_ndarrays, int num_buffers, PyObject* data,
                                   SerializedPyObject* out);

/// \brief Reconstruct Python object from Arrow-serialized representation
/// \param[in] context Serialization context which contains custom serialization
/// and deserialization callbacks. Can be any Python object with a
/// _serialize_callback method for serialization and a _deserialize_callback
/// method for deserialization. If context is None, no custom serialization
/// will be attempted.
/// \param[in] object Object to deserialize
/// \param[in] base a Python object holding the underlying data that any NumPy
/// arrays will reference, to avoid premature deallocation
/// \param[out] out The returned object
/// \return Status
/// This acquires the GIL
ARROW_PYTHON_EXPORT
Status DeserializeObject(PyObject* context, const SerializedPyObject& object,
                         PyObject* base, PyObject** out);

/// \brief Reconstruct Ndarray from Arrow-serialized representation
/// \param[in] object Object to deserialize
/// \param[out] out The deserialized tensor
/// \return Status
ARROW_PYTHON_EXPORT
Status DeserializeNdarray(const SerializedPyObject& object, std::shared_ptr<Tensor>* out);

ARROW_PYTHON_EXPORT
Status NdarrayFromBuffer(std::shared_ptr<Buffer> src, std::shared_ptr<Tensor>* out);

}  // namespace py
}  // namespace arrow

cmd: