Streaming, Serialization, and IPC

Writing and Reading Streams

Arrow defines two types of binary formats for serializing record batches:

  • Streaming format: for sending an arbitrary length sequence of record batches. The format must be processed from start to end, and does not support random access

  • File or Random Access format: for serializing a fixed number of record batches. Supports random access, and thus is very useful when used with memory maps

To follow this section, make sure to first read the section on Memory and IO.

Using streams

First, let’s create a small record batch:

In [1]: import pyarrow as pa

In [2]: data = [
   ...:     pa.array([1, 2, 3, 4]),
   ...:     pa.array(['foo', 'bar', 'baz', None]),
   ...:     pa.array([True, None, False, True])
   ...: ]
   ...: 

In [3]: batch = pa.record_batch(data, names=['f0', 'f1', 'f2'])

In [4]: batch.num_rows
Out[4]: 4

In [5]: batch.num_columns
Out[5]: 3

Now, we can begin writing a stream containing some number of these batches. For this we use RecordBatchStreamWriter, which can write to a writeable NativeFile object or a writeable Python object. For convenience, this one can be created with new_stream():

In [6]: sink = pa.BufferOutputStream()

In [7]: writer = pa.ipc.new_stream(sink, batch.schema)

Here we used an in-memory Arrow buffer stream, but this could have been a socket or some other IO sink.

When creating the StreamWriter, we pass the schema, since the schema (column names and types) must be the same for all of the batches sent in this particular stream. Now we can do:

In [8]: for i in range(5):
   ...:    writer.write_batch(batch)
   ...: 

In [9]: writer.close()

In [10]: buf = sink.getvalue()

In [11]: buf.size
Out[11]: 1984

Now buf contains the complete stream as an in-memory byte buffer. We can read such a stream with RecordBatchStreamReader or the convenience function pyarrow.ipc.open_stream:

In [12]: reader = pa.ipc.open_stream(buf)

In [13]: reader.schema
Out[13]: 
f0: int64
f1: string
f2: bool

In [14]: batches = [b for b in reader]

In [15]: len(batches)
Out[15]: 5

We can check the returned batches are the same as the original input:

In [16]: batches[0].equals(batch)
Out[16]: True

An important point is that if the input source supports zero-copy reads (e.g. like a memory map, or pyarrow.BufferReader), then the returned batches are also zero-copy and do not allocate any new memory on read.

Writing and Reading Random Access Files

The RecordBatchFileWriter has the same API as RecordBatchStreamWriter. You can create one with new_file():

In [17]: sink = pa.BufferOutputStream()

In [18]: writer = pa.ipc.new_file(sink, batch.schema)

In [19]: for i in range(10):
   ....:    writer.write_batch(batch)
   ....: 

In [20]: writer.close()

In [21]: buf = sink.getvalue()

In [22]: buf.size
Out[22]: 4226

The difference between RecordBatchFileReader and RecordBatchStreamReader is that the input source must have a seek method for random access. The stream reader only requires read operations. We can also use the open_file() method to open a file:

In [23]: reader = pa.ipc.open_file(buf)

Because we have access to the entire payload, we know the number of record batches in the file, and can read any at random:

In [24]: reader.num_record_batches
Out[24]: 10

In [25]: b = reader.get_batch(3)

In [26]: b.equals(batch)
Out[26]: True

Reading from Stream and File Format for pandas

The stream and file reader classes have a special read_pandas method to simplify reading multiple record batches and converting them to a single DataFrame output:

In [27]: df = pa.ipc.open_file(buf).read_pandas()

In [28]: df[:5]
Out[28]: 
   f0    f1     f2
0   1   foo   True
1   2   bar   None
2   3   baz  False
3   4  None   True
4   1   foo   True

Arbitrary Object Serialization

Warning

The custom serialization functionality is deprecated in pyarrow 2.0, and will be removed in a future version.

While the serialization functions in this section utilize the Arrow stream protocol internally, they do not produce data that is compatible with the above ipc.open_file and ipc.open_stream functions.

For arbitrary objects, you can use the standard library pickle functionality instead. For pyarrow objects, you can use the IPC serialization format through the pyarrow.ipc module, as explained above.

PyArrow serialization was originally meant to provide a higher-performance alternative to pickle thanks to zero-copy semantics. However, pickle protocol 5 gained support for zero-copy using out-of-band buffers, and can be used instead for similar benefits.

In pyarrow we are able to serialize and deserialize many kinds of Python objects. As an example, consider a dictionary containing NumPy arrays:

In [29]: import numpy as np

In [30]: data = {
   ....:     i: np.random.randn(500, 500)
   ....:     for i in range(100)
   ....: }
   ....: 

We use the pyarrow.serialize function to convert this data to a byte buffer:

In [31]: buf = pa.serialize(data).to_buffer()

In [32]: type(buf)
Out[32]: pyarrow.lib.Buffer

In [33]: buf.size
Out[33]: 200028928

pyarrow.serialize creates an intermediate object which can be converted to a buffer (the to_buffer method) or written directly to an output stream.

pyarrow.deserialize converts a buffer-like object back to the original Python object:

In [34]: restored_data = pa.deserialize(buf)

In [35]: restored_data[0]
Out[35]: 
array([[-1.50630598, -0.03821745,  0.56254254, ..., -0.52737596,
         0.83146633, -0.48987414],
       [-0.05235379, -0.49046579,  2.21743442, ..., -0.49003364,
         0.2459528 ,  2.19551957],
       [-0.18445323,  0.93852978,  1.48636563, ..., -0.9623095 ,
        -0.47134993,  1.83653901],
       ...,
       [ 1.17210124,  0.38002021,  0.76984949, ..., -0.47184521,
         1.07438628, -2.54700667],
       [-0.56608728,  0.35147257, -1.17761138, ..., -0.5487372 ,
        -0.42672977,  1.51695099],
       [-0.53659504,  0.10295632,  0.84794437, ...,  1.8263659 ,
        -1.46168433, -0.98391343]])

Serializing Custom Data Types

If an unrecognized data type is encountered when serializing an object, pyarrow will fall back on using pickle for converting that type to a byte string. There may be a more efficient way, though.

Consider a class with two members, one of which is a NumPy array:

class MyData:
    def __init__(self, name, data):
        self.name = name
        self.data = data

We write functions to convert this to and from a dictionary with simpler types:

def _serialize_MyData(val):
    return {'name': val.name, 'data': val.data}

def _deserialize_MyData(data):
    return MyData(data['name'], data['data']

then, we must register these functions in a SerializationContext so that MyData can be recognized:

context = pa.SerializationContext()
context.register_type(MyData, 'MyData',
                      custom_serializer=_serialize_MyData,
                      custom_deserializer=_deserialize_MyData)

Lastly, we use this context as an additional argument to pyarrow.serialize:

buf = pa.serialize(val, context=context).to_buffer()
restored_val = pa.deserialize(buf, context=context)

The SerializationContext also has convenience methods serialize and deserialize, so these are equivalent statements:

buf = context.serialize(val).to_buffer()
restored_val = context.deserialize(buf)

Component-based Serialization

For serializing Python objects containing some number of NumPy arrays, Arrow buffers, or other data types, it may be desirable to transport their serialized representation without having to produce an intermediate copy using the to_buffer method. To motivate this, suppose we have a list of NumPy arrays:

In [36]: import numpy as np

In [37]: data = [np.random.randn(10, 10) for i in range(5)]

The call pa.serialize(data) does not copy the memory inside each of these NumPy arrays. This serialized representation can be then decomposed into a dictionary containing a sequence of pyarrow.Buffer objects containing metadata for each array and references to the memory inside the arrays. To do this, use the to_components method:

In [38]: serialized = pa.serialize(data)

In [39]: components = serialized.to_components()

The particular details of the output of to_components are not too important. The objects in the 'data' field are pyarrow.Buffer objects, which are zero-copy convertible to Python memoryview objects:

In [40]: memoryview(components['data'][0])
Out[40]: <memory at 0x7f058c966640>

A memoryview can be converted back to a Arrow Buffer with pyarrow.py_buffer:

In [41]: mv = memoryview(components['data'][0])

In [42]: buf = pa.py_buffer(mv)

An object can be reconstructed from its component-based representation using deserialize_components:

In [43]: restored_data = pa.deserialize_components(components)

In [44]: restored_data[0]
Out[44]: 
array([[-1.42834439, -0.19649127,  0.29142153, -1.16718343,  0.40261499,
         0.24414495,  0.82954436, -0.43092503, -0.44967794,  0.85272161],
       [-1.22259354,  1.26206558, -1.50844454,  1.12513961,  0.65514001,
         1.85836232, -2.78446656,  0.09881482, -0.04632969, -1.08824074],
       [ 0.93018763, -0.52934353, -0.45151   ,  0.6592082 , -0.334935  ,
         1.21075926, -0.0074318 ,  0.14427543,  0.44248958, -0.26853323],
       [ 2.50704017,  0.72528671, -2.02881825,  2.42477344,  1.51031386,
         1.36224413,  0.52907757, -0.1142832 ,  1.27978658,  0.01298055],
       [ 0.31756551, -1.56466459,  0.87546874, -0.03968101,  0.69179549,
         0.54007393,  0.06203127,  0.95351691, -0.66615135, -0.99547001],
       [-0.29546935,  0.29616718,  1.65560607,  0.27164244,  1.33162213,
         1.61239514,  0.46608478, -0.25873096, -0.64821163,  0.34120705],
       [-0.31589294, -1.86341363,  0.08628015,  0.22626099,  1.97404273,
         1.20505254, -0.31303259,  0.41387417, -0.4126778 ,  1.84150297],
       [ 0.43301004, -1.37840819, -0.61895866, -0.84535355,  0.2094006 ,
         0.68135283,  0.7514012 , -0.33153216, -3.76106965,  0.14691476],
       [ 1.84949244, -2.26297472,  0.93009666, -0.79663969,  1.60243157,
         1.43096622,  2.31539867,  0.24687942, -0.83571561, -0.59468598],
       [-0.0048335 , -0.2326388 , -0.35872042, -0.9132781 ,  0.3102893 ,
        -0.52582872,  0.19059483, -2.38444497,  0.86387515,  0.0281775 ]])

deserialize_components is also available as a method on SerializationContext objects.