How to check if an array is masked?

[jrueb]

I would like to check if my array is masked. If it is masked, I need to apply some extra logic. Example:

a = ak.unflatten([1,2,3,4,5], [2,2,1])
b = ak.mask(a, a != 1)

Now if I call a function on a or b I would like to be able to check if the input array had ak.mask called on it or not. i can think of several solutions, but they all seem a bit too complicated. I was looking for something like ak.is_masked(arr, axis) but was unable to find it.

[agoose77]

We don't as-yet have a routine to do this. A "hacky" way is to check the type string, but if you want to specify an axis, we should write a proper visitor to do this. Your proposed function might look something like this:

def is_masked(array, axis=1):
    # To support Py 2, we can't use nonlocal
    state = {
        "posaxis": axis, 
        "is_mask": False
    }

    def apply(layout, depth):
        posaxis = state['posaxis'] = layout.axis_wrap_if_negative(state['posaxis'])
        if (depth == posaxis + 1) and isinstance(layout, ak._util.optiontypes):
            state['is_mask'] = True

    layout = ak.to_layout(array)
    ak._util.recursive_walk(layout, apply)

    return state['is_mask']

It's not perfect (we don't exit out early once we find the right axis), but it demonstrates the point.

[jpivarski]

The type that gets returned is not a string, it's an object, and inspecting that is not hacky.

>>> isinstance(b.type.type.type, ak.types.OptionType)
True

That could be a recursive walk, depending on what your requirements are for wanting to find these things is. For instance, will you always be wanting to ask the question at the same axis depth? Would you be going through record structures? @agoose77's solution is like a general-purpose function we might add to the library, maybe with a name like is_optiontype, as some of the ways you can get option types is not through masking (IndexedOptionArray). Maybe that recursive function should also operate on Type objects, since you're asking a question about types? (And then maybe it should be a single implementation on Types, starting from the array.type if given an array, so that it won't materialize VirtualArrays...)

The downside of using the Type object as I've presented it above is that I didn't think it was being widely used and I'm taking advantage of that to change the interface for Awkward v2. Nested types will, in the future, be accessed as .content, rather than .type, to conform to how it's done in arrays and Forms. So in v2, the above would have to be

>>> isinstance(b.type.content.content, ak.types.OptionType)
True

and any recursive function would be descending on .content, rather than .type.