Indexing structures numpy arrays with nested flexible types (np.void type)

I would like to index into a structured numpy array with a nested typing. For example,

a = np.array([((1.,2.),1),((2.,1.),2)], dtype=[('blah',[('beep','f'),('boop','f')]),('num','i')])

I can access 'beep' and 'boop' like this,

>>> a['blah'][['beep','boop']] 
array([(1., 2.), (2., 1.)], dtype=[('row', '<f4'), ('col', '<f4')])

but is there some way I can do this without first indexing 'blah' separately? For example, I would like to do

>>> a[['blah',['beep','boop']]]

but this returns,

<stdin>:1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices

In general, I want to be able to index into an structured array like this for any possible type nesting without having any hard-coded knowledge about how deep the nesting is (or even if it's nested at all).

I would suggest recursively exploring the dtype to get the column of interest.

This example examines each level of the dtype, and prints it if it find a column named either beep or boop.

def recursively_get_columns(array, path=()):
    names = array.dtype.names
    for name in names:
        col = array[name]
        is_simple = col.dtype.names is None
        new_path = path + (name,)
        if is_simple:
            yield new_path, array[name]
        else:
            yield from recursively_get_columns(col, new_path)
for path, col in recursively_get_columns(a):
    if path[-1] in ['beep', 'boop']:
        print(path, col)

Outputs:

('blah', 'beep') [1. 2.]
('blah', 'boop') [2. 1.]

exploring recfunctions

https://numpy.org/devdocs/user/basics.rec.html#module-numpy.lib.recfunctions

In [104]: import numpy.lib.recfunctions as rf

In [105]: a = np.array([((1.,2.),1),((2.,1.),2)], dtype=[('blah',[('beep','f'),('boop','f')]),('num','i')])

In [106]: a.dtype
Out[106]: dtype([('blah', [('beep', '<f4'), ('boop', '<f4')]), ('num', '<i4')])

In [107]: rf.flatten_descr(a.dtype)
Out[107]: 
(('beep', dtype('float32')),
 ('boop', dtype('float32')),
 ('num', dtype('int32')))

In [108]: a.dtype.names
Out[108]: ('blah', 'num')


In [110]: rf.get_names(a.dtype)
Out[110]: (('blah', ('beep', 'boop')), 'num')

In [111]: rf.get_names_flat(a.dtype)
Out[111]: ('blah', 'beep', 'boop', 'num')

This isn't a heavily used library, written I think back in the days when recarray was more common. Now we mostly use the structured array form, or pandas. Mostly these functions explore the dtype, its names, and when making something new, create a 'blank', and copy data by field name.