B
    dl                 @   s   d Z ddlZddlZddlmZ ddlZdddddgZd	Ze	ej
Zeejded
dZdd Zdd ZG dd deZG dd deZG dd deZG dd dedZefddZdddZdddejdfddZdS )z\
A module that provides functions for manipulating bit masks and data quality
(DQ) arrays.

    N)OrderedDictbitfield_to_boolean_maskinterpret_bit_flagsBitFlagNameMapextend_bit_flag_mapInvalidBitFlagTunsafe)dtypecastingc             C   s   | dk rdS t | ddkS )al  
    Verifies if the input number is a bit flag (i.e., an integer number that is
    an integer power of 2).

    Parameters
    ----------
    n : int
        A positive integer number. Non-positive integers are considered not to
        be "flags".

    Returns
    -------
    bool
        ``True`` if input ``n`` is a bit flag and ``False`` if it is not.

       F1)bincount)n r   c/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/astropy/nddata/bitmask.py_is_bit_flag   s    r   c             C   s2   t | tjrt | t p0t | tjo0t| tjS )N)
isinstancenumbersIntegralboolnpZgeneric
issubdtypeinteger)r   r   r   r   _is_int.   s    r   c               @   s   e Zd ZdZdS )r   z@ Indicates that a value is not an integer that is a power of 2. N)__name__
__module____qualname____doc__r   r   r   r   r   5   s   c               @   s   e Zd ZdZdddZdS )BitFlagz1 Bit flags: integer values that are powers of 2. Nc             C   s^   t |tr"|d k	rtd|\}}t|r2t|s@td|t| |}|d k	rZ||_	|S )Nz+Flag's doc string cannot be provided twice.zTValue '{}' is not a valid bit flag: bit flag value must be an integral power of two.)
r   tuple
ValueErrorr   r   r   formatint__new__r   )clsvaldocsr   r   r   r$   <   s    
zBitFlag.__new__)N)r   r   r   r   r$   r   r   r   r   r   :   s   r   c                   s`   e Zd Z fddZ fddZdd Zdd Zd	d
 Zdd Zdd Z	dd Z
dd Z  ZS )BitFlagNameMetac                s$  x&|  D ]\}}|ds
t|}q
W dd | D }tttj|}trTt	 }xh|D ]`}	xZ|	j
  D ]L\}}|dr~qj| }
|
|kr||
}td|| trj|||
< qjW qZW dd |  D }tr|dd |  D  dd	d
|d|i}ndd	d
|}t | |||S )N_c             S   s   g | ]}| d s|qS )r*   )
startswith).0kr   r   r   
<listcomp>T   s    z+BitFlagNameMeta.__new__.<locals>.<listcomp>z$Bit flag '{:s}' was already defined.c             S   s(   i | ] \}}| d r|nt||qS )r*   )r+   r   )r,   r-   vr   r   r   
<dictcomp>f   s   z+BitFlagNameMeta.__new__.<locals>.<dictcomp>c             S   s$   i | ]\}}| d s|| qS )r*   )r+   lower)r,   r-   r/   r   r   r   r0   j   s    T )_locked__version___cache)itemsr+   r   keyslistmapstrr1   _ENABLE_BITFLAG_CACHINGr   __dict__indexAttributeErrorr"   updatesuperr$   )mclsnamebasesmembersr-   r/   attrZattrlcachebklidx)	__class__r   r   r$   O   s4    




zBitFlagNameMeta.__new__c                s   |dkrt  |dS |dkr:| jr,tdt  ||S d| }| jrRt|| }tr||ds|| jkrt|nVx6| jD ],}|ds|t	t
tj|jkrt|qW |t	t
tj| jkrt|t|}tr|ds|| j|< t  ||S )Nr3   Tr4   zVersion cannot be modified.z6Bit flags are read-only. Unable to reassign attribute r*   )r@   __setattr__r3   r>   r1   r;   r+   r5   	__bases__r8   r9   r:   r<   r   )r%   rB   r&   err_msgZnamelrG   )rJ   r   r   rK   s   s,    

 
zBitFlagNameMeta.__setattr__c             C   sl   t r| j}n*dd | j D }|dd | jD  y||  S  tk
rf   td| dY nX d S )Nc             S   s   i | ]\}}||  qS r   )r1   )r,   r-   r/   r   r   r   r0      s    z/BitFlagNameMeta.__getattr__.<locals>.<dictcomp>c             S   s*   i | ]"}|j  D ]\}}|| qqS r   )r<   r6   r1   )r,   rG   r-   r/   r   r   r   r0      s    zFlag 'z' not defined)	r;   r5   r<   r6   r?   rL   r1   KeyErrorr>   )r%   rB   Z	flagnamesr   r   r   __getattr__   s    zBitFlagNameMeta.__getattr__c             C   s
   |  |S )N)rO   )r%   keyr   r   r   __getitem__   s    zBitFlagNameMeta.__getitem__c             C   sR   t |ts*t |d ttfs"|g}t|}t| jd ddd |D  | f|S )Nr   r*   c             S   s   g | ]}|qS r   r   )r,   r-   r   r   r   r.      s    z+BitFlagNameMeta.__add__.<locals>.<listcomp>)r   dictr    r8   r   r   join)r%   r6   r   r   r   __add__   s    
zBitFlagNameMeta.__add__c             C   s   t dd S )Nz8Unary '+' is not supported. Use binary operator instead.)NotImplementedError)r%   otherr   r   r   __iadd__   s    zBitFlagNameMeta.__iadd__c             C   s    t d| j|  d jd S )Nz {:s}: cannot delete {:s} member.)r>   r"   r   mro)r%   rB   r   r   r   __delattr__   s    zBitFlagNameMeta.__delattr__c             C   s    t d| j|  d jd S )Nz {:s}: cannot delete {:s} member.rX   )r>   r"   r   rY   )r%   rB   r   r   r   __delitem__   s    zBitFlagNameMeta.__delitem__c             C   s"   d|   d jdd| jddS )N<rX   r(   z 'z'>)rY   r   )r%   r   r   r   __repr__   s    zBitFlagNameMeta.__repr__)r   r   r   r$   rK   rO   rQ   rT   rW   rZ   r[   r]   __classcell__r   r   )rJ   r   r)   N   s   $!r)   c               @   s   e Zd ZdZdS )r   a<  
    A base class for bit flag name maps used to describe data quality (DQ)
    flags of images by provinding a mapping from a mnemonic flag name to a flag
    value.

    Mapping for a specific instrument should subclass this class.
    Subclasses should define flags as class attributes with integer values
    that are powers of 2. Each bit flag may also contain a string
    comment following the flag value.

    Examples
    --------

        >>> from astropy.nddata.bitmask import BitFlagNameMap
        >>> class ST_DQ(BitFlagNameMap):
        ...     __version__ = '1.0.0'  # optional
        ...     CR = 1, 'Cosmic Ray'
        ...     CLOUDY = 4  # no docstring comment
        ...     RAINY = 8, 'Dome closed'
        ...
        >>> class ST_CAM1_DQ(ST_DQ):
        ...     HOT = 16
        ...     DEAD = 32

    N)r   r   r   r   r   r   r   r   r      s   )	metaclassc             K   s~   t t | |fddi}x\| D ]P\}}yt||| W q  tk
rn } z|| t|kr^|W dd}~X Y q X q W d|_|S )a  
    A convenience function for creating bit flags maps by subclassing an
    existing map and adding additional flags supplied as keyword arguments.

    Parameters
    ----------
    cls_name : str
        Class name of the bit flag map to be created.

    base_cls : BitFlagNameMap, optional
        Base class for the new bit flag map.

    **kwargs : int
        Each supplied keyword argument will be used to define bit flag
        names in the new map. In addition to bit flag names, ``__version__`` is
        allowed to indicate the version of the newly created map.

    Examples
    --------

        >>> from astropy.nddata.bitmask import extend_bit_flag_map
        >>> ST_DQ = extend_bit_flag_map('ST_DQ', __version__='1.0.0', CR=1, CLOUDY=4, RAINY=8)
        >>> ST_CAM1_DQ = extend_bit_flag_map('ST_CAM1_DQ', ST_DQ, HOT=16, DEAD=32)
        >>> ST_CAM1_DQ['HOT']  # <-- Access flags as dictionary keys
        16
        >>> ST_CAM1_DQ.HOT  # <-- Access flags as class attributes
        16

    r3   FNT)r)   r$   r6   setattrr>   r#   r3   )cls_namebase_clskwargsZnew_clsr-   r/   er   r   r   r      s    
c                s  |dk	}t |}d}t r2|r*t  S t S  dkrJ|rFtddS t tr|rbtdt     dkr~dS  d}|dkrd} d	d 	  n|dkrt
d
d}x d} d}|dkr|dkrP ||krt
d d} d}	|dks"|	t d	 k r*t
d d	d   qW t fdddD d	krbt
dd krx d nDd kr d n.d kr d n dkrt
d g dk	r yt d  W n( t
k
r   fdd D  Y nX t d	k}ndt drjtdd  D srdk	r`tdd  D r`fdd D  ntdntd ttt }
t|
t krtd! d}x4|
D ],}t|s|st
d"|||7 }qW |r| }|S )#a  
    Converts input bit flags to a single integer value (bit mask) or `None`.

    When input is a list of flags (either a Python list of integer flags or a
    string of comma-, ``'|'``-, or ``'+'``-separated list of flags),
    the returned bit mask is obtained by summing input flags.

    .. note::
        In order to flip the bits of the returned bit mask,
        for input of `str` type, prepend '~' to the input string. '~' must
        be prepended to the *entire string* and not to each bit flag! For
        input that is already a bit mask or a Python list of bit flags, set
        ``flip_bits`` for `True` in order to flip the bits of the returned
        bit mask.

    Parameters
    ----------
    bit_flags : int, str, list, None
        An integer bit mask or flag, `None`, a string of comma-, ``'|'``- or
        ``'+'``-separated list of integer bit flags or mnemonic flag names,
        or a Python list of integer bit flags. If ``bit_flags`` is a `str`
        and if it is prepended with '~', then the output bit mask will have
        its bits flipped (compared to simple sum of input flags).
        For input ``bit_flags`` that is already a bit mask or a Python list
        of bit flags, bit-flipping can be controlled through ``flip_bits``
        parameter.

        .. note::
            When ``bit_flags`` is a list of flag names, the ``flag_name_map``
            parameter must be provided.

        .. note::
            Only one flag separator is supported at a time. ``bit_flags``
            string should not mix ``','``, ``'+'``, and ``'|'`` separators.

    flip_bits : bool, None
        Indicates whether or not to flip the bits of the returned bit mask
        obtained from input bit flags. This parameter must be set to `None`
        when input ``bit_flags`` is either `None` or a Python list of flags.

    flag_name_map : BitFlagNameMap
         A `BitFlagNameMap` object that provides mapping from mnemonic
         bit flag names to integer bit values in order to translate mnemonic
         flags to numeric values when ``bit_flags`` that are comma- or
         '+'-separated list of menmonic bit flag names.

    Returns
    -------
    bitmask : int or None
        Returns an integer bit mask formed from the input bit value or `None`
        if input ``bit_flags`` parameter is `None` or an empty string.
        If input string value was prepended with '~' (or ``flip_bits`` was set
        to `True`), then returned value will have its bits flipped
        (inverse mask).

    Examples
    --------

        >>> from astropy.nddata.bitmask import interpret_bit_flags, extend_bit_flag_map
        >>> ST_DQ = extend_bit_flag_map('ST_DQ', CR=1, CLOUDY=4, RAINY=8, HOT=16, DEAD=32)
        >>> "{0:016b}".format(0xFFFF & interpret_bit_flags(28))
        '0000000000011100'
        >>> "{0:016b}".format(0xFFFF & interpret_bit_flags('4,8,16'))
        '0000000000011100'
        >>> "{0:016b}".format(0xFFFF & interpret_bit_flags('CLOUDY,RAINY,HOT', flag_name_map=ST_DQ))
        '0000000000011100'
        >>> "{0:016b}".format(0xFFFF & interpret_bit_flags('~4,8,16'))
        '1111111111100011'
        >>> "{0:016b}".format(0xFFFF & interpret_bit_flags('~(4+8+16)'))
        '1111111111100011'
        >>> "{0:016b}".format(0xFFFF & interpret_bit_flags('~(CLOUDY+RAINY+HOT)',
        ... flag_name_map=ST_DQ))
        '1111111111100011'
        >>> "{0:016b}".format(0xFFFF & interpret_bit_flags([4, 8, 16]))
        '0000000000011100'
        >>> "{0:016b}".format(0xFFFF & interpret_bit_flags([4, 8, 16], flip_bits=True))
        '1111111111100011'

    NFzRKeyword argument 'flip_bits' must be set to 'None' when input 'bit_flags' is None.zKeyword argument 'flip_bits' is not permitted for comma-separated string lists of bit flags. Prepend '~' to the string to indicate bit-flipping.)r2   NONEZINDEF~r   Tr   z'Bitwise-NOT must precede bit flag list.()z(Unbalanced parantheses in bit flag list.zAIncorrect syntax (incorrect use of parenthesis) in bit flag list.c             3   s   | ]}| kV  qd S )Nr   )r,   r-   )	bit_flagsr   r   	<genexpr>  s    z&interpret_bit_flags.<locals>.<genexpr>z+,|zlOnly one type of bit flag separator may be used in one expression. Allowed separators are: '+', '|', or ','.,+|r2   zTEmpty bit flag lists not allowed when either bitwise-NOT or parenthesis are present.c                s   g | ]} | qS r   r   )r,   f)flag_name_mapr   r   r.     s    z'interpret_bit_flags.<locals>.<listcomp>__iter__c             S   s   g | ]}t |qS r   )r   )r,   flagr   r   r   r.     s    c             S   s   g | ]}t |tqS r   )r   r:   )r,   rr   r   r   r   r.     s   c                s   g | ]} | qS r   r   )r,   ro   )rp   r   r   r.     s    zSEvery bit flag in a list must be either an integer flag value or a 'str' flag name.z*Unsupported type for argument 'bit_flags'.z#Duplicate bit flags will be ignoredz>Input list contains invalid (not powers of two) bit flag: {:d})r   r   r#   	TypeErrorr   r:   stripupperfindlstripr!   r   rfindlensumsplithasattrallsetr9   warningswarnr   r"   )rj   	flip_bitsrp   Zhas_flip_bitsZallow_non_flagsZbitflip_posZnlparZnrparZlpar_posZrpar_posZbitsetZbitmaskr/   r   )rj   rp   r   r     s    P












Fc             C   s   t | } t | jt js"tdt|||d}|dkr^|rLt j| |d}nt j| |d}|S |t	@ }t j
|| jdd}t j| t jd}t j| ||dd |rt j||d |j|d	d	d
S )a^)  
    bitfield_to_boolean_mask(bitfield, ignore_flags=None, flip_bits=None, good_mask_value=False, dtype=numpy.bool_)
    Converts an array of bit fields to a boolean (or integer) mask array
    according to a bit mask constructed from the supplied bit flags (see
    ``ignore_flags`` parameter).

    This function is particularly useful to convert data quality arrays to
    boolean masks with selective filtering of DQ flags.

    Parameters
    ----------
    bitfield : ndarray
        An array of bit flags. By default, values different from zero are
        interpreted as "bad" values and values equal to zero are considered
        as "good" values. However, see ``ignore_flags`` parameter on how to
        selectively ignore some bits in the ``bitfield`` array data.

    ignore_flags : int, str, list, None (default = 0)
        An integer bit mask, `None`, a Python list of bit flags, a comma-,
        or ``'|'``-separated, ``'+'``-separated string list of integer
        bit flags or mnemonic flag names that indicate what bits in the input
        ``bitfield`` should be *ignored* (i.e., zeroed), or `None`.

        .. note::
            When ``bit_flags`` is a list of flag names, the ``flag_name_map``
            parameter must be provided.

        | Setting ``ignore_flags`` to `None` effectively will make
          `bitfield_to_boolean_mask` interpret all ``bitfield`` elements
          as "good" regardless of their value.

        | When ``ignore_flags`` argument is an integer bit mask, it will be
          combined using bitwise-NOT and bitwise-AND with each element of the
          input ``bitfield`` array (``~ignore_flags & bitfield``). If the
          resultant bitfield element is non-zero, that element will be
          interpreted as a "bad" in the output boolean mask and it will be
          interpreted as "good" otherwise. ``flip_bits`` parameter may be used
          to flip the bits (``bitwise-NOT``) of the bit mask thus effectively
          changing the meaning of the ``ignore_flags`` parameter from "ignore"
          to "use only" these flags.

        .. note::

            Setting ``ignore_flags`` to 0 effectively will assume that all
            non-zero elements in the input ``bitfield`` array are to be
            interpreted as "bad".

        | When ``ignore_flags`` argument is a Python list of integer bit
          flags, these flags are added together to create an integer bit mask.
          Each item in the list must be a flag, i.e., an integer that is an
          integer power of 2. In order to flip the bits of the resultant
          bit mask, use ``flip_bits`` parameter.

        | Alternatively, ``ignore_flags`` may be a string of comma- or
          ``'+'``(or ``'|'``)-separated list of integer bit flags that should
          be added (bitwise OR) together to create an integer bit mask.
          For example, both ``'4,8'``, ``'4|8'``, and ``'4+8'`` are equivalent
          and indicate that bit flags 4 and 8 in the input ``bitfield``
          array should be ignored when generating boolean mask.

        .. note::

            ``'None'``, ``'INDEF'``, and empty (or all white space) strings
            are special values of string ``ignore_flags`` that are
            interpreted as `None`.

        .. note::

            Each item in the list must be a flag, i.e., an integer that is an
            integer power of 2. In addition, for convenience, an arbitrary
            **single** integer is allowed and it will be interpretted as an
            integer bit mask. For example, instead of ``'4,8'`` one could
            simply provide string ``'12'``.

        .. note::
            Only one flag separator is supported at a time. ``ignore_flags``
            string should not mix ``','``, ``'+'``, and ``'|'`` separators.

        .. note::

            When ``ignore_flags`` is a `str` and when it is prepended with
            '~', then the meaning of ``ignore_flags`` parameters will be
            reversed: now it will be interpreted as a list of bit flags to be
            *used* (or *not ignored*) when deciding which elements of the
            input ``bitfield`` array are "bad". Following this convention,
            an ``ignore_flags`` string value of ``'~0'`` would be equivalent
            to setting ``ignore_flags=None``.

        .. warning::

            Because prepending '~' to a string ``ignore_flags`` is equivalent
            to setting ``flip_bits`` to `True`, ``flip_bits`` cannot be used
            with string ``ignore_flags`` and it must be set to `None`.

    flip_bits : bool, None (default = None)
        Specifies whether or not to invert the bits of the bit mask either
        supplied directly through ``ignore_flags`` parameter or built from the
        bit flags passed through ``ignore_flags`` (only when bit flags are
        passed as Python lists of integer bit flags). Occasionally, it may be
        useful to *consider only specific bit flags* in the ``bitfield``
        array when creating a boolean mask as opposed to *ignoring* specific
        bit flags as ``ignore_flags`` behaves by default. This can be achieved
        by inverting/flipping the bits of the bit mask created from
        ``ignore_flags`` flags which effectively changes the meaning of the
        ``ignore_flags`` parameter from "ignore" to "use only" these flags.
        Setting ``flip_bits`` to `None` means that no bit flipping will be
        performed. Bit flipping for string lists of bit flags must be
        specified by prepending '~' to string bit flag lists
        (see documentation for ``ignore_flags`` for more details).

        .. warning::
            This parameter can be set to either `True` or `False` **ONLY** when
            ``ignore_flags`` is either an integer bit mask or a Python
            list of integer bit flags. When ``ignore_flags`` is either
            `None` or a string list of flags, ``flip_bits`` **MUST** be set
            to `None`.

    good_mask_value : int, bool (default = False)
        This parameter is used to derive the values that will be assigned to
        the elements in the output boolean mask array that correspond to the
        "good" bit fields (that are 0 after zeroing bits specified by
        ``ignore_flags``) in the input ``bitfield`` array. When
        ``good_mask_value`` is non-zero or ``numpy.True_`` then values in the
        output boolean mask array corresponding to "good" bit fields in
        ``bitfield`` will be ``numpy.True_`` (if ``dtype`` is ``numpy.bool_``)
        or 1 (if ``dtype`` is of numerical type) and values of corresponding
        to "bad" flags will be ``numpy.False_`` (or 0). When
        ``good_mask_value`` is zero or ``numpy.False_`` then the values
        in the output boolean mask array corresponding to "good" bit fields
        in ``bitfield`` will be ``numpy.False_`` (if ``dtype`` is
        ``numpy.bool_``) or 0 (if ``dtype`` is of numerical type) and values
        of corresponding to "bad" flags will be ``numpy.True_`` (or 1).

    dtype : data-type (default = ``numpy.bool_``)
        The desired data-type for the output binary mask array.

    flag_name_map : BitFlagNameMap
         A `BitFlagNameMap` object that provides mapping from mnemonic
         bit flag names to integer bit values in order to translate mnemonic
         flags to numeric values when ``bit_flags`` that are comma- or
         '+'-separated list of menmonic bit flag names.

    Returns
    -------
    mask : ndarray
        Returns an array of the same dimensionality as the input ``bitfield``
        array whose elements can have two possible values,
        e.g., ``numpy.True_`` or ``numpy.False_`` (or 1 or 0 for integer
        ``dtype``) according to values of to the input ``bitfield`` elements,
        ``ignore_flags`` parameter, and the ``good_mask_value`` parameter.

    Examples
    --------

        >>> from astropy.nddata import bitmask
        >>> import numpy as np
        >>> dqarr = np.asarray([[0, 0, 1, 2, 0, 8, 12, 0],
        ...                     [10, 4, 0, 0, 0, 16, 6, 0]])
        >>> flag_map = bitmask.extend_bit_flag_map(
        ...     'ST_DQ', CR=2, CLOUDY=4, RAINY=8, HOT=16, DEAD=32
        ... )
        >>> bitmask.bitfield_to_boolean_mask(dqarr, ignore_flags=0,
        ...                                  dtype=int)
        array([[0, 0, 1, 1, 0, 1, 1, 0],
               [1, 1, 0, 0, 0, 1, 1, 0]])
        >>> bitmask.bitfield_to_boolean_mask(dqarr, ignore_flags=0,
        ...                                  dtype=bool)
        array([[False, False,  True,  True, False,  True,  True, False],
               [ True,  True, False, False, False,  True,  True, False]]...)
        >>> bitmask.bitfield_to_boolean_mask(dqarr, ignore_flags=6,
        ...                                  good_mask_value=0, dtype=int)
        array([[0, 0, 1, 0, 0, 1, 1, 0],
               [1, 0, 0, 0, 0, 1, 0, 0]])
        >>> bitmask.bitfield_to_boolean_mask(dqarr, ignore_flags=~6,
        ...                                  good_mask_value=0, dtype=int)
        array([[0, 0, 0, 1, 0, 0, 1, 0],
               [1, 1, 0, 0, 0, 0, 1, 0]])
        >>> bitmask.bitfield_to_boolean_mask(dqarr, ignore_flags=6, dtype=int,
        ...                                  flip_bits=True, good_mask_value=0)
        array([[0, 0, 0, 1, 0, 0, 1, 0],
               [1, 1, 0, 0, 0, 0, 1, 0]])
        >>> bitmask.bitfield_to_boolean_mask(dqarr, ignore_flags='~(2+4)',
        ...                                  good_mask_value=0, dtype=int)
        array([[0, 0, 0, 1, 0, 0, 1, 0],
               [1, 1, 0, 0, 0, 0, 1, 0]])
        >>> bitmask.bitfield_to_boolean_mask(dqarr, ignore_flags=[2, 4],
        ...                                  flip_bits=True, good_mask_value=0,
        ...                                  dtype=int)
        array([[0, 0, 0, 1, 0, 0, 1, 0],
               [1, 1, 0, 0, 0, 0, 1, 0]])
        >>> bitmask.bitfield_to_boolean_mask(dqarr, ignore_flags='~(CR,CLOUDY)',
        ...                                  good_mask_value=0, dtype=int,
        ...                                  flag_name_map=flag_map)
        array([[0, 0, 0, 1, 0, 0, 1, 0],
               [1, 1, 0, 0, 0, 0, 1, 0]])
        >>> bitmask.bitfield_to_boolean_mask(dqarr, ignore_flags='~(CR+CLOUDY)',
        ...                                  good_mask_value=0, dtype=int,
        ...                                  flag_name_map=flag_map)
        array([[0, 0, 0, 1, 0, 0, 1, 0],
               [1, 1, 0, 0, 0, 0, 1, 0]])

    z-Input bitfield array must be of integer type.)r   rp   N)r	   r   )r	   r
   )outr
   )r   F)r	   Zsubokcopy)r   Zasarrayr   r	   r   rs   r   Z	ones_likeZ
zeros_like_SUPPORTED_FLAGSbitwise_notZ
empty_likebool_Zbitwise_andZlogical_notZastype)ZbitfieldZignore_flagsr   Zgood_mask_valuer	   rp   Zignore_maskmaskr   r   r   r     s&     O

)NN)r   r   r   collectionsr   numpyr   __all__r;   Zmaximum_sctypeZuintZ_MAX_UINT_TYPEr#   r   r   r   r   r!   r   r   typer)   r   r   r   r   r   r   r   r   r   <module>   s,   
r/
 G