ak.ArrayBuilder
---------------

Defined in `awkward.highlevel <https://github.com/scikit-hep/awkward-1.0/blob/80bbef0738a6b7928333d7c705ee1b359991de5b/src/awkward/highlevel.py>`__ on `line 2095 <https://github.com/scikit-hep/awkward-1.0/blob/80bbef0738a6b7928333d7c705ee1b359991de5b/src/awkward/highlevel.py#L2095>`__.

.. py:class:: ak.ArrayBuilder(self, behavior=None, initial=1024, resize=1.5)


    :param behavior: Custom :py:obj:`ak.behavior` for arrays built by
                 this ArrayBuilder.
    :type behavior: None or dict
    :param initial: Initial size (in bytes) of buffers used by
                :py:obj:`ak.layout.ArrayBuilder` (see :py:obj:`ak.layout.ArrayBuilderOptions`).
    :type initial: int
    :param resize: Resize multiplier for buffers used by
               :py:obj:`ak.layout.ArrayBuilder` (see :py:obj:`ak.layout.ArrayBuilderOptions`);
               should be strictly greater than 1.
    :type resize: float

General tool for building arrays of nested data structures from a sequence
of commands. Most data types can be constructed by calling commands in the
right order, similar to printing tokens to construct JSON output.

To illustrate how this works, consider the following example.

.. code-block:: python


    b = ak.ArrayBuilder()

    # fill commands   # as JSON   # current array type
    ##########################################################################################
    b.begin_list()    # [         # 0 * var * unknown     (initially, the type is unknown)
    b.integer(1)      #   1,      # 0 * var * int64
    b.integer(2)      #   2,      # 0 * var * int64
    b.real(3)         #   3.0     # 0 * var * float64     (all the integers have become floats)
    b.end_list()      # ],        # 1 * var * float64
    b.begin_list()    # [         # 1 * var * float64
    b.end_list()      # ],        # 2 * var * float64
    b.begin_list()    # [         # 2 * var * float64
    b.integer(4)      #   4,      # 2 * var * float64
    b.null()          #   null,   # 2 * var * ?float64    (now the floats are nullable)
    b.integer(5)      #   5       # 2 * var * ?float64
    b.end_list()      # ],        # 3 * var * ?float64
    b.begin_list()    # [         # 3 * var * ?float64
    b.begin_record()  #   {       # 3 * var * ?union[float64, {}]
    b.field("x")      #     "x":  # 3 * var * ?union[float64, {"x": unknown}]
    b.integer(1)      #      1,   # 3 * var * ?union[float64, {"x": int64}]
    b.field("y")      #      "y": # 3 * var * ?union[float64, {"x": int64, "y": unknown}]
    b.begin_list()    #      [    # 3 * var * ?union[float64, {"x": int64, "y": var * unknown}]
    b.integer(2)      #        2, # 3 * var * ?union[float64, {"x": int64, "y": var * int64}]
    b.integer(3)      #        3  # 3 * var * ?union[float64, {"x": int64, "y": var * int64}]
    b.end_list()      #      ]    # 3 * var * ?union[float64, {"x": int64, "y": var * int64}]
    b.end_record()    #   }       # 3 * var * ?union[float64, {"x": int64, "y": var * int64}]
    b.end_list()      # ]         # 4 * var * ?union[float64, {"x": int64, "y": var * int64}]

To get an array, we take a :py:meth:`snapshot <ak.ArrayBuilder.snapshot>` of the ArrayBuilder's current state.

.. code-block:: python


    >>> ak.to_list(b.snapshot())
    [[1.0, 2.0, 3.0], [], [4.0, None, 5.0], [{'x': 1, 'y': [2, 3]}]]

The full set of filling commands is the following.

   * :py:meth:`null <ak.ArrayBuilder.null>`: appends a None value.
   * :py:meth:`boolean <ak.ArrayBuilder.boolean>`: appends True or False.
   * :py:meth:`integer <ak.ArrayBuilder.integer>`: appends an integer.
   * :py:meth:`real <ak.ArrayBuilder.real>`: appends a floating-point value.
   * :py:meth:`complex <ak.ArrayBuilder.complex>`: appends a complex value.
   * :py:meth:`datetime <ak.ArrayBuilder.datetime>`: appends a datetime value.
   * :py:meth:`timedelta <ak.ArrayBuilder.timedelta>`: appends a timedelta value.
   * :py:meth:`bytestring <ak.ArrayBuilder.bytestring>`: appends an unencoded string (raw bytes).
   * :py:meth:`string <ak.ArrayBuilder.string>`: appends a UTF-8 encoded string.
   * :py:meth:`begin_list <ak.ArrayBuilder.begin_list>`: begins filling a list; must be closed with :py:meth:`end_list <ak.ArrayBuilder.end_list>`.
   * :py:meth:`end_list <ak.ArrayBuilder.end_list>`: ends a list.
   * :py:meth:`begin_tuple <ak.ArrayBuilder.begin_tuple>`: begins filling a tuple; must be closed with :py:meth:`end_tuple <ak.ArrayBuilder.end_tuple>`.
   * :py:meth:`index <ak.ArrayBuilder.index>`: selects a tuple slot to fill; must be followed by a command
     that actually fills that slot.
   * :py:meth:`end_tuple <ak.ArrayBuilder.end_tuple>`: ends a tuple.
   * :py:meth:`begin_record <ak.ArrayBuilder.begin_record>`: begins filling a record; must be closed with
     :py:meth:`end_record <ak.ArrayBuilder.end_record>`.
   * :py:meth:`field <ak.ArrayBuilder.field>`: selects a record field to fill; must be followed by a command
     that actually fills that field.
   * :py:meth:`end_record <ak.ArrayBuilder.end_record>`: ends a record.
   * :py:meth:`append <ak.ArrayBuilder.append>`: generic method for filling :py:meth:`null <ak.ArrayBuilder.null>`, :py:meth:`boolean <ak.ArrayBuilder.boolean>`, :py:meth:`integer <ak.ArrayBuilder.integer>`, :py:meth:`real <ak.ArrayBuilder.real>`,
     :py:meth:`bytestring <ak.ArrayBuilder.bytestring>`, :py:meth:`string <ak.ArrayBuilder.string>`, :py:obj:`ak.Array`, :py:obj:`ak.Record`, or arbitrary Python data.
     When filling from :py:obj:`ak.Array` or :py:obj:`ak.Record`, the output holds references
     to the original data, rather than copying.
   * :py:meth:`list <ak.ArrayBuilder.list>`: context manager for :py:meth:`begin_list <ak.ArrayBuilder.begin_list>` and :py:meth:`end_list <ak.ArrayBuilder.end_list>`.
   * :py:meth:`tuple <ak.ArrayBuilder.tuple>`: context manager for :py:meth:`begin_tuple <ak.ArrayBuilder.begin_tuple>` and :py:meth:`end_tuple <ak.ArrayBuilder.end_tuple>`.
   * :py:meth:`record <ak.ArrayBuilder.record>`: context manager for :py:meth:`begin_record <ak.ArrayBuilder.begin_record>` and :py:meth:`end_record <ak.ArrayBuilder.end_record>`.

ArrayBuilders can be used in `Numba <http://numba.pydata.org/>`__: they can
be passed as arguments to a Numba-compiled function or returned as return
values. (Since ArrayBuilder works by accumulating side-effects, it's not
strictly necessary to return the object.)

The primary limitation is that ArrayBuilders cannot be *created* and
:py:meth:`snapshot <ak.ArrayBuilder.snapshot>` cannot be called inside the Numba-compiled function. Awkward
Array uses Numba as a transformer: :py:obj:`ak.Array` and an empty :py:obj:`ak.ArrayBuilder`
go in and a filled :py:obj:`ak.ArrayBuilder` is the result; :py:meth:`snapshot <ak.ArrayBuilder.snapshot>` can be called
outside of the compiled function.

Also, context managers (Python's ``with`` statement) are not supported in
Numba yet, so the :py:meth:`list <ak.ArrayBuilder.list>`, :py:meth:`tuple <ak.ArrayBuilder.tuple>`, and :py:meth:`record <ak.ArrayBuilder.record>` methods are not available
in Numba-compiled functions.

Here is an example of filling an ArrayBuilder in Numba, which makes a
tree of dynamic depth.

.. code-block:: python


    >>> import numba as nb
    >>> @nb.njit
    ... def deepnesting(builder, probability):
    ...     if np.random.uniform(0, 1) > probability:
    ...         builder.append(np.random.normal())
    ...     else:
    ...         builder.begin_list()
    ...         for i in range(np.random.poisson(3)):
    ...             deepnesting(builder, probability**2)
    ...         builder.end_list()
    ...
    >>> builder = ak.ArrayBuilder()
    >>> deepnesting(builder, 0.9)
    >>> builder.snapshot()
    <Array [... 1.23, -0.498, 0.272], -0.0519]]]] type='1 * var * var * union[var * ...'>
    >>> ak.to_list(builder)
    [[[[2.05, 0.95], [[[0.25], 1.86, 0.89, 0.31], 0.38, -1.62, [[0.18], 0.46, 0.39], [-0.57, 1.39, -0.15, -0.20]], [[[-0.74, -0.34], -0.84], [-0.81, -0.72, -0.42, [1.04, 1.69, -0.18, 1.07]]], [[0.51]]], [[-1.97, 0.57], [-1.24, -2.14, -0.54, [[0.24, -2.31, [-0.68, 0.08], 1.80, 0.16], -0.63, [0.01, [-1.28, 0.38, 1.40, -0.26, -0.48]]], -0.62, -2.53], [-1.66, 0.58]], [0.62, [[-0.76, -0.67, -1.15], -0.50, [0.36, 0.48, -0.80, [1.15, -1.09], -1.39, 1.28]], 0.93, [1.35, [0.36, 1.09, -0.27, -0.79], [-0.41], [0.67, 0.89, 0.79]], [], [0.67, [-0.48, -0.39], 1.06, 0.80, -0.34], [[1.56, -1.60, [-0.69], -0.42], 0.33, -0.73, 0.50, -1.25, -1.15], [[0.64], [-0.01], -0.95], [[0.41, -0.68, 0.79], 0.51]], [[0.62, [0.58, -0.75]], [1.61, 0.52, 0.24], -1.09, [-1.11], 0.22], [-0.41, [[0.42], 0.78, [1.22, -0.49, 0.27], -0.05xs]]]]
    >>> ak.type(builder.snapshot())
    1 * var * var * union[var * union[float64, var * union[var * union[float64, var * float64], float64]], float64]

Note that this is a *general* method for building arrays; if the type is
known in advance, more specialized procedures can be faster. This should
be considered the "least effort" approach.

ak.ArrayBuilder._wrap
=====================

.. py:method:: ak.ArrayBuilder._wrap(cls, layout, behavior=None)


    :param layout: Low-level builder to wrap.
    :type layout: :py:obj:`ak.layout.ArrayBuilder`
    :param behavior: Custom :py:obj:`ak.behavior` for arrays built by
                 this ArrayBuilder.
    :type behavior: None or dict

Wraps a low-level :py:obj:`ak.layout.ArrayBuilder` as a high-level
:py:obj:`ak.ArrayBuilder`.

The :py:obj:`ak.ArrayBuilder` constructor creates a new :py:obj:`ak.layout.ArrayBuilder`
with no accumulated data, but Numba needs to wrap existing data
when returning from a lowered function.

ak.ArrayBuilder.behavior
========================

.. py:attribute:: ak.ArrayBuilder.behavior

The ``behavior`` parameter passed into this ArrayBuilder's constructor.

   * If a dict, this ``behavior`` overrides the global :py:obj:`ak.behavior`.
     Any keys in the global :py:obj:`ak.behavior` but not this ``behavior`` are
     still valid, but any keys in both are overridden by this
     ``behavior``. Keys with a None value are equivalent to missing keys,
     so this ``behavior`` can effectively remove keys from the
     global :py:obj:`ak.behavior`.

   * If None, the Array defaults to the global :py:obj:`ak.behavior`.

See :py:obj:`ak.behavior` for a list of recognized key patterns and their
meanings.

ak.ArrayBuilder.type
====================

.. py:attribute:: ak.ArrayBuilder.type

The high-level type of the accumulated array; same as :py:obj:`ak.type`.

Note that the outermost element of an Array's type is always an
:py:obj:`ak.types.ArrayType`, which specifies the number of elements in the array.

The type of a :py:obj:`ak.layout.Content` (from :py:obj:`ak.Array.layout`) is not
wrapped by an :py:obj:`ak.types.ArrayType`.

ak.ArrayBuilder.__len__
=======================

.. py:method:: ak.ArrayBuilder.__len__(self)

The current length of the accumulated array.

ak.ArrayBuilder.__getitem__
===========================

.. py:method:: ak.ArrayBuilder.__getitem__(self, where)


    :param where: Index of positions to
              select from the array.
    :type where: many types supported; see below

Takes a :py:meth:`snapshot <ak.ArrayBuilder.snapshot>` and selects items from the array.

See :py:obj:`ak.Array.__getitem__` for a more complete description.

ak.ArrayBuilder.__iter__
========================

.. py:method:: ak.ArrayBuilder.__iter__(self)

Iterates over a :py:meth:`snapshot <ak.ArrayBuilder.snapshot>` of the array in Python.

See :py:obj:`ak.Array.__iter__` for performance considerations.

ak.ArrayBuilder.__str__
=======================

.. py:method:: ak.ArrayBuilder.__str__(self)


    :param limit_value: Maximum number of characters to use when
                    presenting the ArrayBuilder as a string.
    :type limit_value: int

Presents this ArrayBuilder as a string without type or
``"<ArrayBuilder ...>"``.

See :py:obj:`ak.Array.__str__` for a more complete description.

ak.ArrayBuilder.__repr__
========================

.. py:method:: ak.ArrayBuilder.__repr__(self)


    :param limit_value: Maximum number of characters to use when
                    presenting the data of the ArrayBuilder.
    :type limit_value: int
    :param limit_total: Maximum number of characters to use for
                    the whole string (should be larger than ``limit_value``).
    :type limit_total: int

Presents this ArrayBuilder as a string with its type and
``"<ArrayBuilder ...>"``.

See :py:obj:`ak.Array.__repr__` for a more complete description.

ak.ArrayBuilder._str
====================

.. py:method:: ak.ArrayBuilder._str(self, limit_value=85, snapshot=None)

ak.ArrayBuilder._repr
=====================

.. py:method:: ak.ArrayBuilder._repr(self, limit_value=40, limit_total=85)

ak.ArrayBuilder.__array__
=========================

.. py:method:: ak.ArrayBuilder.__array__(self)

Intercepts attempts to convert a :py:meth:`snapshot <ak.ArrayBuilder.snapshot>` of this array into a
NumPy array and either performs a zero-copy conversion or raises
an error.

See :py:obj:`ak.Array.__array__` for a more complete description.

ak.ArrayBuilder.__array_ufunc__
===============================

.. py:method:: ak.ArrayBuilder.__array_ufunc__(self, ufunc, method)

Intercepts attempts to pass this ArrayBuilder to a NumPy
`universal functions <https://docs.scipy.org/doc/numpy/reference/ufuncs.html>`__
(ufuncs) and passes it through the structure of the array's :py:meth:`snapshot <ak.ArrayBuilder.snapshot>`.

See :py:obj:`ak.Array.__array_ufunc__` for a more complete description.

ak.ArrayBuilder.__array_function__
==================================

.. py:method:: ak.ArrayBuilder.__array_function__(self, func, types, args, kwargs)

Intercepts attempts to pass this ArrayBuilder to those NumPy functions
other than universal functions that have an Awkward equivalent.

See :py:obj:`ak.ArrayBuilder.__array_ufunc__` for a more complete description.

ak.ArrayBuilder.numba_type
==========================

.. py:attribute:: ak.ArrayBuilder.numba_type

The type of this Array when it is used in Numba. It contains enough
information to generate low-level code for accessing any element,
down to the leaves.

See `Numba documentation <https://numba.pydata.org/numba-doc/dev/reference/types.html>`__
on types and signatures.

ak.ArrayBuilder.__bool__
========================

.. py:method:: ak.ArrayBuilder.__bool__(self)

ak.ArrayBuilder.snapshot
========================

.. py:method:: ak.ArrayBuilder.snapshot(self)

Converts the currently accumulated data into an :py:obj:`ak.Array`.

This is almost always an *O(1)* operation (does not scale with the
size of the accumulated data, and therefore safe to call relatively
often).

The resulting :py:obj:`ak.Array` shares memory with the accumulated data (it
is a zero-copy operation), but it is safe to continue filling the
ArrayBuilder because its append-only operations only affect data
outside the range viewed by old snapshots. If ArrayBuilder reallocates
an internal buffer, the data are no longer shared, but they're
reference-counted by the :py:obj:`ak.Array` and the :py:obj:`ak.ArrayBuilder`, so all
buffers are deleted exactly once.

ak.ArrayBuilder.null
====================

.. py:method:: ak.ArrayBuilder.null(self)

Appends a None value at the current position in the accumulated array.

ak.ArrayBuilder.boolean
=======================

.. py:method:: ak.ArrayBuilder.boolean(self, x)

Appends a boolean value ``x`` at the current position in the accumulated
array.

ak.ArrayBuilder.integer
=======================

.. py:method:: ak.ArrayBuilder.integer(self, x)

Appends an integer ``x`` at the current position in the accumulated
array.

ak.ArrayBuilder.real
====================

.. py:method:: ak.ArrayBuilder.real(self, x)

Appends a floating point number ``x`` at the current position in the
accumulated array.

ak.ArrayBuilder.complex
=======================

.. py:method:: ak.ArrayBuilder.complex(self, x)

Appends a floating point number ``x`` at the current position in the
accumulated array.

ak.ArrayBuilder.datetime
========================

.. py:method:: ak.ArrayBuilder.datetime(self, x)

Appends a datetime value ``x`` at the current position in the
accumulated array.

ak.ArrayBuilder.timedelta
=========================

.. py:method:: ak.ArrayBuilder.timedelta(self, x)

Appends a timedelta value ``x`` at the current position in the
accumulated array.

ak.ArrayBuilder.bytestring
==========================

.. py:method:: ak.ArrayBuilder.bytestring(self, x)

Appends an unencoded string (raw bytes) ``x`` at the current position
in the accumulated array.

ak.ArrayBuilder.string
======================

.. py:method:: ak.ArrayBuilder.string(self, x)

Appends a UTF-8 encoded string ``x`` at the current position in the
accumulated array.

ak.ArrayBuilder.begin_list
==========================

.. py:method:: ak.ArrayBuilder.begin_list(self)

Begins filling a list; must be closed with :py:meth:`end_list <ak.ArrayBuilder.end_list>`.

For example,

.. code-block:: python


    builder.begin_list()
    builder.real(1.1)
    builder.real(2.2)
    builder.real(3.3)
    builder.end_list()
    builder.begin_list()
    builder.end_list()
    builder.begin_list()
    builder.real(4.4)
    builder.real(5.5)
    builder.end_list()

produces

.. code-block:: python


    [[1.1, 2.2, 3.3], [], [4.4, 5.5]]

ak.ArrayBuilder.end_list
========================

.. py:method:: ak.ArrayBuilder.end_list(self)

Ends a list.

ak.ArrayBuilder.begin_tuple
===========================

.. py:method:: ak.ArrayBuilder.begin_tuple(self, numfields)

Begins filling a tuple with ``numfields`` fields; must be closed with
:py:meth:`end_tuple <ak.ArrayBuilder.end_tuple>`.

For example,

.. code-block:: python


    builder.begin_tuple(3)
    builder.index(0).integer(1)
    builder.index(1).real(1.1)
    builder.index(2).string("one")
    builder.end_tuple()
    builder.begin_tuple(3)
    builder.index(0).integer(2)
    builder.index(1).real(2.2)
    builder.index(2).string("two")
    builder.end_tuple()

produces

.. code-block:: python


    [(1, 1.1, "one"), (2, 2.2, "two")]

ak.ArrayBuilder.index
=====================

.. py:method:: ak.ArrayBuilder.index(self, i)


    :param i: The tuple slot to fill.
    :type i: int

This method also returns the :py:obj:`ak.ArrayBuilder`, so that it can be
chained with the value that fills the slot.

Prepares to fill a tuple slot; see :py:meth:`begin_tuple <ak.ArrayBuilder.begin_tuple>` for an example.

ak.ArrayBuilder.end_tuple
=========================

.. py:method:: ak.ArrayBuilder.end_tuple(self)

Ends a tuple.

ak.ArrayBuilder.begin_record
============================

.. py:method:: ak.ArrayBuilder.begin_record(self, name=None)

Begins filling a record with an optional ``name``; must be closed with
:py:meth:`end_record <ak.ArrayBuilder.end_record>`.

For example,

.. code-block:: python


    >>> builder = ak.ArrayBuilder()
    >>> builder.begin_record("points")
    >>> builder.field("x").real(1)
    >>> builder.field("y").real(1.1)
    >>> builder.end_record()
    >>> builder.begin_record("points")
    >>> builder.field("x").real(2)
    >>> builder.field("y").real(2.2)
    >>> builder.end_record()

produces

.. code-block:: python


    >>> ak.to_list(builder.snapshot())
    [{"x": 1.0, "y": 1.1}, {"x": 2.0, "y": 2.2}]

with type

.. code-block:: python


    >>> ak.type(builder.snapshot())
    2 * points["x": float64, "y": float64]

The record type is named ``"points"`` because its ``"__record__"``
parameter is set to that value:

.. code-block:: python


    >>> builder.snapshot().layout.parameters
    {'__record__': 'points'}

The ``"__record__"`` parameter can be used to add behavior to the records
in the array, as described in :py:obj:`ak.Array`, :py:obj:`ak.Record`, and :py:obj:`ak.behavior`.

ak.ArrayBuilder.field
=====================

.. py:method:: ak.ArrayBuilder.field(self, key)


    :param key: The field key to fill.
    :type key: str

This method also returns the :py:obj:`ak.ArrayBuilder`, so that it can be
chained with the value that fills the slot.

Prepares to fill a field; see :py:meth:`begin_record <ak.ArrayBuilder.begin_record>` for an example.

ak.ArrayBuilder.end_record
==========================

.. py:method:: ak.ArrayBuilder.end_record(self)

Ends a record.

ak.ArrayBuilder.append
======================

.. py:method:: ak.ArrayBuilder.append(self, obj)


    :param obj: The object to append.
    :type obj: anything :py:obj:`ak.from_iter` recognizes
    :param at: which value to select from ``obj`` if ``obj`` is
           an :py:obj:`ak.Array`.
    :type at: None or int

Appends a Python object. This method can be used as a shorthand for :py:meth:`null <ak.ArrayBuilder.null>`,
:py:meth:`boolean <ak.ArrayBuilder.boolean>`, :py:meth:`integer <ak.ArrayBuilder.integer>`, :py:meth:`real <ak.ArrayBuilder.real>`, :py:meth:`bytestring <ak.ArrayBuilder.bytestring>`, or :py:meth:`string <ak.ArrayBuilder.string>`.

ak.ArrayBuilder.list
====================

.. py:method:: ak.ArrayBuilder.list(self)

Context manager to prevent unpaired :py:meth:`begin_list <ak.ArrayBuilder.begin_list>` and :py:meth:`end_list <ak.ArrayBuilder.end_list>`. The
example in the :py:meth:`begin_list <ak.ArrayBuilder.begin_list>` documentation can be rewritten as

.. code-block:: python


    with builder.list():
        builder.real(1.1)
        builder.real(2.2)
        builder.real(3.3)
    with builder.list():
        pass
    with builder.list():
        builder.real(4.4)
        builder.real(5.5)

to produce the same result.

.. code-block:: python


    [[1.1, 2.2, 3.3], [], [4.4, 5.5]]

Since context managers aren't yet supported by Numba, this method
can't be used in Numba.

ak.ArrayBuilder.tuple
=====================

.. py:method:: ak.ArrayBuilder.tuple(self, numfields)

Context manager to prevent unpaired :py:meth:`begin_tuple <ak.ArrayBuilder.begin_tuple>` and :py:meth:`end_tuple <ak.ArrayBuilder.end_tuple>`. The
example in the :py:meth:`begin_tuple <ak.ArrayBuilder.begin_tuple>` documentation can be rewritten as

.. code-block:: python


    with builder.tuple(3):
        builder.index(0).integer(1)
        builder.index(1).real(1.1)
        builder.index(2).string("one")
    with builder.tuple(3):
        builder.index(0).integer(2)
        builder.index(1).real(2.2)
        builder.index(2).string("two")

to produce the same result.

.. code-block:: python


    [(1, 1.1, "one"), (2, 2.2, "two")]

Since context managers aren't yet supported by Numba, this method
can't be used in Numba.

ak.ArrayBuilder.record
======================

.. py:method:: ak.ArrayBuilder.record(self, name=None)

Context manager to prevent unpaired :py:meth:`begin_record <ak.ArrayBuilder.begin_record>` and :py:meth:`end_record <ak.ArrayBuilder.end_record>`. The
example in the :py:meth:`begin_record <ak.ArrayBuilder.begin_record>` documentation can be rewritten as

.. code-block:: python


    with builder.record("points"):
        builder.field("x").real(1)
        builder.field("y").real(1.1)
    with builder.record("points"):
        builder.field("x").real(2)
        builder.field("y").real(2.2)

to produce the same result.

.. code-block:: python


    [{"x": 1.0, "y": 1.1}, {"x": 2.0, "y": 2.2}]

Since context managers aren't yet supported by Numba, this method
can't be used in Numba.

