import builtins

import datetime as dt

import functools

import inspect

import operator

import re

import textwrap

import warnings

import numpy as np

import numpy._core.numerictypes as ntypes

import numpy._core.umath as umath

from numpy import (

_NoValue,

amax,

amin,

angle,

array as narray,

bool_,

expand_dims,

finfo, # noqa: F401

iinfo, # noqa: F401

iscomplexobj,

ndarray,

)

from numpy._core import multiarray as mu

from numpy._core.numeric import normalize_axis_tuple

from numpy._utils import set_module

__all__ = [

]

MaskType = np.bool

nomask = MaskType(0)

class MaskedArrayFutureWarning(FutureWarning):

pass

def _deprecate_argsort_axis(arr):

return None

def doc_note(initialdoc, note):

return ''.join(notesplit[:1] + [notedoc] + notesplit[1:])

class MAError(Exception):

pass

class MaskError(MAError):

pass

default_filler = {'b': True,

}

for v in ["Y", "M", "W", "D", "h", "m", "s", "ms", "us", "ns", "ps",

"fs", "as"]:

default_filler["M8[" + v + "]"] = np.datetime64("NaT", v)

default_filler["m8[" + v + "]"] = np.timedelta64("NaT", v)

float_types_list = [np.half, np.single, np.double, np.longdouble,

np.csingle, np.cdouble, np.clongdouble]

_minvals: dict[type, int] = {}

_maxvals: dict[type, int] = {}

for sctype in ntypes.sctypeDict.values():

scalar_dtype = np.dtype(sctype)

if scalar_dtype.kind in "Mm":

info = np.iinfo(np.int64)

min_val, max_val = info.min + 1, info.max

elif np.issubdtype(scalar_dtype, np.integer):

info = np.iinfo(sctype)

min_val, max_val = info.min, info.max

elif np.issubdtype(scalar_dtype, np.floating):

info = np.finfo(sctype)

min_val, max_val = info.min, info.max

elif scalar_dtype.kind == "b":

min_val, max_val = 0, 1

else:

min_val, max_val = None, None

_minvals[sctype] = min_val

_maxvals[sctype] = max_val

max_filler = _minvals

max_filler.update([(k, -np.inf) for k in float_types_list[:4]])

max_filler.update([(k, complex(-np.inf, -np.inf)) for k in float_types_list[-3:]])

min_filler = _maxvals

min_filler.update([(k, +np.inf) for k in float_types_list[:4]])

min_filler.update([(k, complex(+np.inf, +np.inf)) for k in float_types_list[-3:]])

del float_types_list

def _recursive_fill_value(dtype, f):

return f(dtype)

def _get_dtype_of(obj):

return np.asanyarray(obj).dtype

def default_fill_value(obj):

return _recursive_fill_value(dtype, _scalar_fill_value)

def _check_fill_value_or_default(fill_value, ndtype):

return None

def _extremum_fill_value(obj, extremum, extremum_name):

return _recursive_fill_value(dtype, _scalar_fill_value)

def minimum_fill_value(obj):

return _extremum_fill_value(obj, min_filler, "minimum")

def maximum_fill_value(obj):

return _extremum_fill_value(obj, max_filler, "maximum")

def _recursive_set_fill_value(fillvalue, dt):

return tuple(output_value)

def _check_fill_value(fill_value, ndtype):

return np.array(fill_value)

def set_fill_value(a, fill_value):

a.set_fill_value(fill_value)

def get_fill_value(a):

return result

def common_fill_value(a, b):

return None

def filled(a, fill_value=None):

return np.array(a)

def get_masked_subclass(*arrays):

return rcls

def getdata(a, subok=True):

return data

get_data = getdata

def fix_invalid(a, mask=nomask, copy=True, fill_value=None):

return a

def is_string_or_list_of_strings(val):

return (isinstance(val, str) or

(isinstance(val, list) and val and

builtins.all(isinstance(s, str) for s in val)))

ufunc_domain = {}

ufunc_fills = {}

class _DomainCheckInterval:

umath.less(x, self.a))

class _DomainTan:

return umath.less(umath.absolute(umath.cos(x)), self.eps)

class _DomainSafeDivide:

return umath.absolute(a) * self.tolerance >= umath.absolute(b)

class _DomainGreater:

return umath.less_equal(x, self.critical_value)

class _DomainGreaterEqual:

return umath.less(x, self.critical_value)

class _MaskedUFunc:

return f"Masked version of {self.f}"

class _MaskedUnaryOperation(_MaskedUFunc):