Generic way to detect a tuple structure?

[masonproffitt]

Is there a short and easy top-level way to check if an Array has a tuple structure? That is, if the fields refer to elements of tuples. For a plain RecordArray, you can do:

>>> a = ak.Array([(1, 2)])
>>> a.layout
<RecordArray length="1">
    <field index="0">
        <NumpyArray format="l" shape="1" data="1" at="0x55e8e613deb0"/>
    </field>
    <field index="1">
        <NumpyArray format="l" shape="1" data="2" at="0x55e8e613ded0"/>
    </field>
</RecordArray>
>>> a.layout.istuple
True

but this doesn't work at higher depths:

>>> b = ak.Array([[(1, 2)]])
>>> b.layout
<ListOffsetArray64>
    <offsets><Index64 i="[0 1]" offset="0" length="2" at="0x55e8e613d600"/></offsets>
    <content><RecordArray length="1">
        <field index="0">
            <NumpyArray format="l" shape="1" data="1" at="0x55e8e66aa9c0"/>
        </field>
        <field index="1">
            <NumpyArray format="l" shape="1" data="2" at="0x55e8e667b330"/>
        </field>
    </RecordArray></content>
</ListOffsetArray64>
>>> b.layout.istuple
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'awkward._ext.ListOffsetArray64' object has no attribute 'istuple'

In this case, you could do b.layout.content.istuple, but the point is that this is not generic to all ak.Arrays. Another option is b.fields == [str(i) for i in range(len(b.fields))], but this would lead to false positives for RecordArrays that have fields explicitly named '0', '1', etc.

Am I missing a simple way to check this or does this feature not exist?

[agoose77]

Right now, I we don't expose this information at the top-level. ak.Array has the fields attribute which returns ak.operations.describe.fields(self), but we don't yet have an equivalent for istuple.

In v2, we are a bit better at making tuples and records behave predictably with respect to numeric (albeit in string form) fields, but there is still no function to test the entire layout for any tuple. #1351 is one solution for this.

For now, you can do this with a layout visitor:

def is_tuple(array):
    layout = ak.to_layout(array, allow_record=True)

    def visitor(layout):
        if isinstance(layout, (ak.layout.Record, ak.layout.RecordArray)):
            return layout.istuple
        elif isinstance(
            layout, ak._util.listtypes + ak._util.optiontypes + ak._util.indexedtypes
        ):
            return visitor(layout.content)
        elif isinstance(layout, ak.layout.VirtualArray):
            return visitor(layout.array)
        elif isinstance(layout, ak._util.uniontypes):
            return all(visitor(x) for x in layout.contents)
        elif isinstance(layout, ak.layout.NumpyArray):
            return False
        else:
            raise ValueError

    return visitor(layout)

Note that unions over records as non-tuples are a less well defined concept (are they tuples if they have different fields?). Here I'm considering a union of tuples as a tuple, even if they have differing numbers of fields.

[jpivarski]

Am I missing a simple way to check this or does this feature not exist?

The feature doesn't exist. @agoose77's sample code would be a good implementation of it, but the ak._util.recursively_apply interface changes between version 1 and 2, so it would be better to not use that in downstream code. (The underscore in _util is supposed to hide it.) #516 is a request that the interface be made public, and we could do that in version 2, since the new interface is better thought-through.

(We'd do it by adding a high-level function that calls Content._recursively_apply or ak._v2._broadcasting.broadcast_and_apply, depending on whether there's one array or multiple. The interfaces for these two are now the same. Adding a new public function to call into this interface is better than just exposing the existing one because that gives us wiggle room to change our internal function without making those changes public.)

Getting back to this question, an ak.is_tuple could live alongside ak.fields. It would be a reasonable high-level interface to have. (Do Forms/Types already do it? That kind of thing can be known from the Form or Type alone.)

[jpivarski]

It looks like you've already gotten started on this: #1351. Great!