Thansk @ImenRajhi and @alinanesen!

The tests are failing because the input to np.ma.unique can be either a regular numpy array or a masked array:

>       output = np.unique(ar1.data[~ar1.mask],
                           return_index=return_index,
                           return_inverse=return_inverse)
E       AttributeError: 'numpy.ndarray' object has no attribute 'mask'

So you'll want to only use the mask if it's actually a masked array. You can special-case this with a if isinstance(ar1, MaskedArray) for example.

Try to run the tests locally to see this failure, then it's much easier to iterate than if you have to wait on CI. For example:

python runtests.py -s ma

to run all the numpy.ma tests.

Thanks for pointing that out @rgommers.

After a second look I realized we have misdiagnosed the problem. Here are my findings:

1. The problem behind this behavior: the ordering of dtype extremities and the masked values are not defined while sorting.
2. How exactly is that causing this behavior: Unique calls for sort and sort does not know how to order masked and extremes and therefore e.g. of np.uint8: sort([255, --, 255, --]) -> outputs [255, --, 255, --]. Afterwards unique will compare pairwise and will keep everything thus the weird behavior (outputs [255, --, 255, --]). The same example but with the input rearranged [255, 255, --, --] will output the correct results of [255, --].
3. The solution: define the ordering of dtype extremities and the masked values.

More details:
The np.ma.argsort fills in the masked array with the fill_value. The fill value always ends up being the dtype maximum as fill_value is passed null and endwith is default True. Therefore input [255, --, 255, --] becomes a filled array: [255, 255, 255, 255]. Then filled array is sorted and right there the sorting strange behavior happens.

Nice analysis @ImenRajhi. Indeed, sort is a little odd:

>>> x = np.ma.array([4,3,2,1], mask=[True, False, True, False])
>>> np.ma.sort(x)
masked_array(data=[1, 3, --, --],
             mask=[False, False,  True,  True],
       fill_value=999999)
>>> y = np.ma.array([4,255,2,1], dtype=np.uint8, mask=[True, False, True, False])
>>> np.ma.sort(y)
masked_array(data=[1, --, 255, --],
             mask=[False,  True, False,  True],
       fill_value=999999,
            dtype=uint8)

The current behavior was thought about and document as being undefined in gh-8678. That said, I don't see a real discussion about it on that PR, and I also don't see why it would not be possible to sort masked values to the end. Correctness is more important than performance here. argsort and sort behavior should match, and argsort does the actual work - so MaskedArray.argsort is the method to fix.

The current behavior was thought about and document as being undefined in gh-8678

@eric-wieser it's 4 years ago, but do you recollect why you decided to document this as undefined behavior?

I think I decided that it was a hard problem to fix without adding substantial runtime overhead, and didn't have any evidence to suggest anyone really cared anyway; so I figured I'd just document what was already happening.

That's not to say I'm opposed to it being fixed; I just didn't have the motivation to do it myself, and left that docstring to prevent people being surprised.

Hi @ImenRajhi, did you close this on purpose? We can continue to add to this PR, I think the fix is going in the right direction.

Sorry @rgommers, small misunderstanding on my part. I reopened it.

I'm going to close this as "Good Idea", but inactive. @ImenRajhi Feel free to continue this work in a new PR.