"""

A collection of utility functions and classes. Originally, many

(but not all) were from the Python Cookbook -- hence the name cbook.

This module is safe to import from anywhere within matplotlib;

it imports matplotlib only at runtime.

"""

import collections

import collections.abc

import contextlib

import functools

import glob

import gzip

import itertools

import locale

import numbers

import operator

import os

from pathlib import Path

import re

import shlex

import subprocess

import sys

import time

import traceback

import types

import warnings

import weakref

from weakref import WeakMethod

import numpy as np

import matplotlib

from .deprecation import (

deprecated, warn_deprecated,

_rename_parameter, _delete_parameter, _make_keyword_only,

_suppress_matplotlib_deprecation_warning,

MatplotlibDeprecationWarning, mplDeprecation)

def _exception_printer(exc):

traceback.print_exc()

class _StrongRef:

"""

Wrapper similar to a weakref, but keeping a strong reference to the object.

"""

def __init__(self, obj):

self._obj = obj

def __call__(self):

return self._obj

def __eq__(self, other):

return isinstance(other, _StrongRef) and self._obj == other._obj

def __hash__(self):

return hash(self._obj)

class CallbackRegistry:

"""Handle registering and disconnecting for a set of signals and callbacks:

>>> def oneat(x):

... print('eat', x)

>>> def ondrink(x):

... print('drink', x)

>>> from matplotlib.cbook import CallbackRegistry

>>> callbacks = CallbackRegistry()

>>> id_eat = callbacks.connect('eat', oneat)

>>> id_drink = callbacks.connect('drink', ondrink)

>>> callbacks.process('drink', 123)

drink 123

>>> callbacks.process('eat', 456)

eat 456

>>> callbacks.process('be merry', 456) # nothing will be called

>>> callbacks.disconnect(id_eat)

>>> callbacks.process('eat', 456) # nothing will be called

In practice, one should always disconnect all callbacks when they are

no longer needed to avoid dangling references (and thus memory leaks).

However, real code in Matplotlib rarely does so, and due to its design,

it is rather difficult to place this kind of code. To get around this,

and prevent this class of memory leaks, we instead store weak references

to bound methods only, so when the destination object needs to die, the

CallbackRegistry won't keep it alive.

Parameters

----------

exception_handler : callable, optional

If provided must have signature ::

def handler(exc: Exception) -> None:

If not None this function will be called with any `Exception`

subclass raised by the callbacks in `CallbackRegistry.process`.

The handler may either consume the exception or re-raise.

The callable must be pickle-able.

The default handler is ::

def h(exc):

traceback.print_exc()

"""

# We maintain two mappings:

# callbacks: signal -> {cid -> callback}

# _func_cid_map: signal -> {callback -> cid}

# (actually, callbacks are weakrefs to the actual callbacks).

def __init__(self, exception_handler=_exception_printer):

self.exception_handler = exception_handler

self.callbacks = {}

self._cid_gen = itertools.count()

self._func_cid_map = {}

# In general, callbacks may not be pickled; thus, we simply recreate an

# empty dictionary at unpickling. In order to ensure that `__setstate__`

# (which just defers to `__init__`) is called, `__getstate__` must

# return a truthy value (for pickle protocol>=3, i.e. Py3, the

# *actual* behavior is that `__setstate__` will be called as long as

# `__getstate__` does not return `None`, but this is undocumented -- see

# http://bugs.python.org/issue12290).

def __getstate__(self):

return {'exception_handler': self.exception_handler}

def __setstate__(self, state):

self.__init__(**state)

def connect(self, s, func):

"""Register *func* to be called when signal *s* is generated.

"""

self._func_cid_map.setdefault(s, {})

try:

proxy = WeakMethod(func, self._remove_proxy)

except TypeError:

proxy = _StrongRef(func)

if proxy in self._func_cid_map[s]:

return self._func_cid_map[s][proxy]

cid = next(self._cid_gen)

self._func_cid_map[s][proxy] = cid

self.callbacks.setdefault(s, {})

self.callbacks[s][cid] = proxy

return cid

# Keep a reference to sys.is_finalizing, as sys may have been cleared out

# at that point.

def _remove_proxy(self, proxy, *, _is_finalizing=sys.is_finalizing):

if _is_finalizing():

# Weakrefs can't be properly torn down at that point anymore.

return

for signal, proxies in list(self._func_cid_map.items()):

try:

del self.callbacks[signal][proxies[proxy]]

except KeyError:

pass

if len(self.callbacks[signal]) == 0:

del self.callbacks[signal]

del self._func_cid_map[signal]

def disconnect(self, cid):

"""Disconnect the callback registered with callback id *cid*.

"""

for eventname, callbackd in list(self.callbacks.items()):

try:

del callbackd[cid]

except KeyError:

continue

else:

for signal, functions in list(self._func_cid_map.items()):

for function, value in list(functions.items()):

if value == cid:

del functions[function]

return

def process(self, s, *args, **kwargs):

"""

Process signal *s*.

All of the functions registered to receive callbacks on *s* will be

called with ``*args`` and ``**kwargs``.

"""

for cid, ref in list(self.callbacks.get(s, {}).items()):

func = ref()

if func is not None:

try:

func(*args, **kwargs)

# this does not capture KeyboardInterrupt, SystemExit,

# and GeneratorExit

except Exception as exc:

if self.exception_handler is not None:

self.exception_handler(exc)

else:

raise

class silent_list(list):

"""

A list with a short ``repr()``.

This is meant to be used for a homogeneous list of artists, so that they

don't cause long, meaningless output.

Instead of ::

[<matplotlib.lines.Line2D object at 0x7f5749fed3c8>,

<matplotlib.lines.Line2D object at 0x7f5749fed4e0>,

<matplotlib.lines.Line2D object at 0x7f5758016550>]

one will get ::

<a list of 3 Line2D objects>

"""

def __init__(self, type, seq=None):

self.type = type

if seq is not None:

self.extend(seq)

def __repr__(self):

return '<a list of %d %s objects>' % (len(self), self.type)

__str__ = __repr__

def __getstate__(self):

# store a dictionary of this SilentList's state

return {'type': self.type, 'seq': self[:]}

def __setstate__(self, state):

self.type = state['type']

self.extend(state['seq'])

class IgnoredKeywordWarning(UserWarning):

"""

A class for issuing warnings about keyword arguments that will be ignored

by Matplotlib.

"""

pass

def local_over_kwdict(local_var, kwargs, *keys):

"""

Enforces the priority of a local variable over potentially conflicting

argument(s) from a kwargs dict. The following possible output values are

considered in order of priority::

local_var > kwargs[keys[0]] > ... > kwargs[keys[-1]]

The first of these whose value is not None will be returned. If all are

None then None will be returned. Each key in keys will be removed from the

kwargs dict in place.

Parameters

----------

local_var : any object

The local variable (highest priority).

kwargs : dict

Dictionary of keyword arguments; modified in place.

keys : str(s)

Name(s) of keyword arguments to process, in descending order of

priority.

Returns

-------

out : any object

Either local_var or one of kwargs[key] for key in keys.

Raises

------

IgnoredKeywordWarning

For each key in keys that is removed from kwargs but not used as

the output value.

"""

out = local_var

for key in keys:

kwarg_val = kwargs.pop(key, None)

if kwarg_val is not None:

if out is None:

out = kwarg_val

else:

_warn_external('"%s" keyword argument will be ignored' % key,

IgnoredKeywordWarning)

return out

def strip_math(s):

"""

Remove latex formatting from mathtext.

Only handles fully math and fully non-math strings.

"""

if len(s) >= 2 and s[0] == s[-1] == "$":

s = s[1:-1]

for tex, plain in [

(r"\times", "x"), # Specifically for Formatter support.

(r"\mathdefault", ""),

(r"\rm", ""),

(r"\cal", ""),

(r"\tt", ""),

(r"\it", ""),

("\\", ""),

("{", ""),

("}", ""),

]:

s = s.replace(tex, plain)

return s

@deprecated('3.1', alternative='np.iterable')

def iterable(obj):

"""return true if *obj* is iterable"""

try:

iter(obj)

except TypeError:

return False

return True

@deprecated("3.1", alternative="isinstance(..., collections.abc.Hashable)")

def is_hashable(obj):

"""Returns true if *obj* can be hashed"""

try:

hash(obj)

except TypeError:

return False

return True

def is_writable_file_like(obj):

"""Return whether *obj* looks like a file object with a *write* method."""

return callable(getattr(obj, 'write', None))

def file_requires_unicode(x):

"""

Return whether the given writable file-like object requires Unicode to be

written to it.

"""

try:

x.write(b'')

except TypeError:

return True

else:

return False

def to_filehandle(fname, flag='r', return_opened=False, encoding=None):

"""

Convert a path to an open file handle or pass-through a file-like object.

Consider using `open_file_cm` instead, as it allows one to properly close

newly created file objects more easily.

Parameters

----------

fname : str or path-like or file-like object

If `str` or `os.PathLike`, the file is opened using the flags specified

by *flag* and *encoding*. If a file-like object, it is passed through.

flag : str, default 'r'

Passed as the *mode* argument to `open` when *fname* is `str` or

`os.PathLike`; ignored if *fname* is file-like.

return_opened : bool, default False

If True, return both the file object and a boolean indicating whether

this was a new file (that the caller needs to close). If False, return

only the new file.

encoding : str or None, default None

Passed as the *mode* argument to `open` when *fname* is `str` or

`os.PathLike`; ignored if *fname* is file-like.

Returns

-------

fh : file-like

opened : bool

*opened* is only returned if *return_opened* is True.

"""

if isinstance(fname, os.PathLike):

fname = os.fspath(fname)

if isinstance(fname, str):

if fname.endswith('.gz'):

# get rid of 'U' in flag for gzipped files.

flag = flag.replace('U', '')

fh = gzip.open(fname, flag)

elif fname.endswith('.bz2'):

# python may not be complied with bz2 support,

# bury import until we need it

import bz2

# get rid of 'U' in flag for bz2 files

flag = flag.replace('U', '')

fh = bz2.BZ2File(fname, flag)

else:

fh = open(fname, flag, encoding=encoding)

opened = True

elif hasattr(fname, 'seek'):

fh = fname

opened = False

else:

raise ValueError('fname must be a PathLike or file handle')

if return_opened:

return fh, opened

return fh

@contextlib.contextmanager

def open_file_cm(path_or_file, mode="r", encoding=None):

r"""Pass through file objects and context-manage `.PathLike`\s."""

fh, opened = to_filehandle(path_or_file, mode, True, encoding)

if opened:

with fh:

yield fh

else:

yield fh

def is_scalar_or_string(val):

"""Return whether the given object is a scalar or string like."""

return isinstance(val, str) or not np.iterable(val)

def get_sample_data(fname, asfileobj=True):

"""

Return a sample data file. *fname* is a path relative to the

`mpl-data/sample_data` directory. If *asfileobj* is `True`

return a file object, otherwise just a file path.

Sample data files are stored in the 'mpl-data/sample_data' directory within

the Matplotlib package.

If the filename ends in .gz, the file is implicitly ungzipped.

"""

path = Path(matplotlib.get_data_path(), 'sample_data', fname)

if asfileobj:

suffix = path.suffix.lower()

if suffix == '.gz':

return gzip.open(path)

elif suffix in ['.csv', '.xrc', '.txt']:

return path.open('r')

else:

return path.open('rb')

else:

return str(path)

def _get_data_path(*args):

"""

Return the `Path` to a resource file provided by Matplotlib.

``*args`` specify a path relative to the base data path.

"""

return Path(matplotlib.get_data_path(), *args)

def flatten(seq, scalarp=is_scalar_or_string):

"""

Return a generator of flattened nested containers.

For example:

>>> from matplotlib.cbook import flatten

>>> l = (('John', ['Hunter']), (1, 23), [[([42, (5, 23)], )]])

>>> print(list(flatten(l)))

['John', 'Hunter', 1, 23, 42, 5, 23]

By: Composite of Holger Krekel and Luther Blissett

From: https://code.activestate.com/recipes/121294/

and Recipe 1.12 in cookbook

"""

for item in seq:

if scalarp(item) or item is None:

yield item

else:

yield from flatten(item, scalarp)

@functools.lru_cache()

def get_realpath_and_stat(path):

realpath = os.path.realpath(path)

stat = os.stat(realpath)

stat_key = (stat.st_ino, stat.st_dev)

return realpath, stat_key

# A regular expression used to determine the amount of space to

# remove. It looks for the first sequence of spaces immediately

# following the first newline, or at the beginning of the string.

_find_dedent_regex = re.compile(r"(?:(?:\n\r?)|^)( *)\S")

# A cache to hold the regexs that actually remove the indent.

_dedent_regex = {}

@deprecated("3.1", alternative="inspect.cleandoc")

def dedent(s):

"""

Remove excess indentation from docstring *s*.

Discards any leading blank lines, then removes up to n whitespace

characters from each line, where n is the number of leading

whitespace characters in the first line. It differs from

textwrap.dedent in its deletion of leading blank lines and its use

of the first non-blank line to determine the indentation.

It is also faster in most cases.

"""

# This implementation has a somewhat obtuse use of regular

# expressions. However, this function accounted for almost 30% of

# matplotlib startup time, so it is worthy of optimization at all

# costs.

if not s: # includes case of s is None

return ''

match = _find_dedent_regex.match(s)

if match is None:

return s

# This is the number of spaces to remove from the left-hand side.

nshift = match.end(1) - match.start(1)

if nshift == 0:

return s

# Get a regex that will remove *up to* nshift spaces from the

# beginning of each line. If it isn't in the cache, generate it.

unindent = _dedent_regex.get(nshift, None)

if unindent is None:

unindent = re.compile("\n\r? {0,%d}" % nshift)

_dedent_regex[nshift] = unindent

result = unindent.sub("\n", s).strip()

return result

class maxdict(dict):

"""

A dictionary with a maximum size.

Notes

-----

This doesn't override all the relevant methods to constrain the size,

just ``__setitem__``, so use with caution.

"""

def __init__(self, maxsize):

dict.__init__(self)

self.maxsize = maxsize

self._killkeys = []

def __setitem__(self, k, v):

if k not in self:

if len(self) >= self.maxsize:

del self[self._killkeys[0]]

del self._killkeys[0]

self._killkeys.append(k)

dict.__setitem__(self, k, v)

class Stack:

"""

Stack of elements with a movable cursor.

Mimics home/back/forward in a web browser.

"""

def __init__(self, default=None):

self.clear()

self._default = default

def __call__(self):

"""Return the current element, or None."""

if not len(self._elements):

return self._default

else:

return self._elements[self._pos]

def __len__(self):

return len(self._elements)

def __getitem__(self, ind):

return self._elements[ind]

def forward(self):

"""Move the position forward and return the current element."""

self._pos = min(self._pos + 1, len(self._elements) - 1)

return self()

def back(self):

"""Move the position back and return the current element."""

if self._pos > 0:

self._pos -= 1

return self()

def push(self, o):

"""

Push *o* to the stack at current position. Discard all later elements.

*o* is returned.

"""

self._elements = self._elements[:self._pos + 1] + [o]

self._pos = len(self._elements) - 1

return self()

def home(self):

"""

Push the first element onto the top of the stack.

The first element is returned.

"""

if not len(self._elements):

return

self.push(self._elements[0])

return self()

def empty(self):

"""Return whether the stack is empty."""

return len(self._elements) == 0

def clear(self):

"""Empty the stack."""

self._pos = -1

self._elements = []

def bubble(self, o):

"""

Raise *o* to the top of the stack. *o* must be present in the stack.

*o* is returned.

"""

if o not in self._elements:

raise ValueError('Unknown element o')

old = self._elements[:]

self.clear()

bubbles = []

for thiso in old:

if thiso == o:

bubbles.append(thiso)

else:

self.push(thiso)

for _ in bubbles:

self.push(o)

return o

def remove(self, o):

"""Remove *o* from the stack."""

if o not in self._elements:

raise ValueError('Unknown element o')

old = self._elements[:]

self.clear()

for thiso in old:

if thiso != o:

self.push(thiso)

def report_memory(i=0): # argument may go away

"""Return the memory consumed by the process."""

def call(command, os_name):

try:

return subprocess.check_output(command)

except subprocess.CalledProcessError:

raise NotImplementedError(

"report_memory works on %s only if "

"the '%s' program is found" % (os_name, command[0])

)

pid = os.getpid()

if sys.platform == 'sunos5':

lines = call(['ps', '-p', '%d' % pid, '-o', 'osz'], 'Sun OS')

mem = int(lines[-1].strip())

elif sys.platform == 'linux':

lines = call(['ps', '-p', '%d' % pid, '-o', 'rss,sz'], 'Linux')

mem = int(lines[1].split()[1])

elif sys.platform == 'darwin':

lines = call(['ps', '-p', '%d' % pid, '-o', 'rss,vsz'], 'Mac OS')

mem = int(lines[1].split()[0])

elif sys.platform == 'win32':

lines = call(["tasklist", "/nh", "/fi", "pid eq %d" % pid], 'Windows')

mem = int(lines.strip().split()[-2].replace(',', ''))

else:

raise NotImplementedError(

"We don't have a memory monitor for %s" % sys.platform)

return mem

_safezip_msg = 'In safezip, len(args[0])=%d but len(args[%d])=%d'

@deprecated("3.1")

def safezip(*args):

"""make sure *args* are equal len before zipping"""

Nx = len(args[0])

for i, arg in enumerate(args[1:]):

if len(arg) != Nx:

raise ValueError(_safezip_msg % (Nx, i + 1, len(arg)))

return list(zip(*args))

def safe_masked_invalid(x, copy=False):

x = np.array(x, subok=True, copy=copy)

if not x.dtype.isnative:

# Note that the argument to `byteswap` is 'inplace',

# thus if we have already made a copy, do the byteswap in

# place, else make a copy with the byte order swapped.

# Be explicit that we are swapping the byte order of the dtype

x = x.byteswap(copy).newbyteorder('S')

try:

xm = np.ma.masked_invalid(x, copy=False)

xm.shrink_mask()

except TypeError:

return x

return xm

def print_cycles(objects, outstream=sys.stdout, show_progress=False):

"""

Print loops of cyclic references in the given *objects*.

It is often useful to pass in ``gc.garbage`` to find the cycles that are

preventing some objects from being garbage collected.

Parameters

----------

objects

A list of objects to find cycles in.

outstream

The stream for output.

show_progress : bool

If True, print the number of objects reached as they are found.

"""

import gc

def print_path(path):

for i, step in enumerate(path):

# next "wraps around"

next = path[(i + 1) % len(path)]

outstream.write(" %s -- " % type(step))

if isinstance(step, dict):

for key, val in step.items():

if val is next:

outstream.write("[{!r}]".format(key))

break

if key is next:

outstream.write("[key] = {!r}".format(val))

break

elif isinstance(step, list):

outstream.write("[%d]" % step.index(next))

elif isinstance(step, tuple):

outstream.write("( tuple )")

else:

outstream.write(repr(step))

outstream.write(" ->\n")

outstream.write("\n")

def recurse(obj, start, all, current_path):

if show_progress:

outstream.write("%d\r" % len(all))

all[id(obj)] = None

referents = gc.get_referents(obj)

for referent in referents:

# If we've found our way back to the start, this is

# a cycle, so print it out

if referent is start:

print_path(current_path)

# Don't go back through the original list of objects, or

# through temporary references to the object, since those

# are just an artifact of the cycle detector itself.

elif referent is objects or isinstance(referent, types.FrameType):

continue

# We haven't seen this object before, so recurse

elif id(referent) not in all:

recurse(referent, start, all, current_path + [obj])

for obj in objects:

outstream.write(f"Examining: {obj!r}\n")

recurse(obj, obj, {}, [])

class Grouper:

"""

This class provides a lightweight way to group arbitrary objects

together into disjoint sets when a full-blown graph data structure

would be overkill.

Objects can be joined using :meth:`join`, tested for connectedness

using :meth:`joined`, and all disjoint sets can be retrieved by

using the object as an iterator.

The objects being joined must be hashable and weak-referenceable.

For example:

>>> from matplotlib.cbook import Grouper

>>> class Foo:

... def __init__(self, s):

... self.s = s

... def __repr__(self):

... return self.s

...

>>> a, b, c, d, e, f = [Foo(x) for x in 'abcdef']

>>> grp = Grouper()

>>> grp.join(a, b)

>>> grp.join(b, c)

>>> grp.join(d, e)

>>> sorted(map(tuple, grp))

[(a, b, c), (d, e)]

>>> grp.joined(a, b)

True

>>> grp.joined(a, c)

True

>>> grp.joined(a, d)

False

"""

def __init__(self, init=()):

self._mapping = {weakref.ref(x): [weakref.ref(x)] for x in init}

def __contains__(self, item):

return weakref.ref(item) in self._mapping

def clean(self):

"""Clean dead weak references from the dictionary."""

mapping = self._mapping

to_drop = [key for key in mapping if key() is None]

for key in to_drop:

val = mapping.pop(key)

val.remove(key)

def join(self, a, *args):

"""

Join given arguments into the same set. Accepts one or more arguments.

"""

mapping = self._mapping

set_a = mapping.setdefault(weakref.ref(a), [weakref.ref(a)])

for arg in args:

set_b = mapping.get(weakref.ref(arg), [weakref.ref(arg)])

if set_b is not set_a:

if len(set_b) > len(set_a):

set_a, set_b = set_b, set_a

set_a.extend(set_b)

for elem in set_b:

mapping[elem] = set_a

self.clean()

def joined(self, a, b):

"""Return whether *a* and *b* are members of the same set."""

self.clean()

return (self._mapping.get(weakref.ref(a), object())

is self._mapping.get(weakref.ref(b)))

def remove(self, a):

self.clean()

set_a = self._mapping.pop(weakref.ref(a), None)

if set_a:

set_a.remove(weakref.ref(a))

def __iter__(self):

"""

Iterate over each of the disjoint sets as a list.

The iterator is invalid if interleaved with calls to join().

"""

self.clean()

unique_groups = {id(group): group for group in self._mapping.values()}

for group in unique_groups.values():

yield [x() for x in group]

def get_siblings(self, a):

"""Return all of the items joined with *a*, including itself."""

self.clean()

siblings = self._mapping.get(weakref.ref(a), [weakref.ref(a)])

return [x() for x in siblings]

def simple_linear_interpolation(a, steps):

"""

Resample an array with ``steps - 1`` points between original point pairs.

Along each column of *a*, ``(steps - 1)`` points are introduced between

each original values; the values are linearly interpolated.

Parameters

----------

a : array, shape (n, ...)

steps : int

Returns

-------

array

shape ``((n - 1) * steps + 1, ...)``

"""

fps = a.reshape((len(a), -1))

xp = np.arange(len(a)) * steps

x = np.arange((len(a) - 1) * steps + 1)

return (np.column_stack([np.interp(x, xp, fp) for fp in fps.T])

.reshape((len(x),) + a.shape[1:]))

def delete_masked_points(*args):

"""

Find all masked and/or non-finite points in a set of arguments,

and return the arguments with only the unmasked points remaining.

Arguments can be in any of 5 categories:

1) 1-D masked arrays

2) 1-D ndarrays

3) ndarrays with more than one dimension

4) other non-string iterables

5) anything else

The first argument must be in one of the first four categories;

any argument with a length differing from that of the first

argument (and hence anything in category 5) then will be

passed through unchanged.

Masks are obtained from all arguments of the correct length

in categories 1, 2, and 4; a point is bad if masked in a masked

array or if it is a nan or inf. No attempt is made to

extract a mask from categories 2, 3, and 4 if :meth:`np.isfinite`

does not yield a Boolean array.

All input arguments that are not passed unchanged are returned

as ndarrays after removing the points or rows corresponding to

masks in any of the arguments.

A vastly simpler version of this function was originally

written as a helper for Axes.scatter().

"""

if not len(args):

return ()

if is_scalar_or_string(args[0]):

raise ValueError("First argument must be a sequence")

nrecs = len(args[0])

margs = []

seqlist = [False] * len(args)

for i, x in enumerate(args):

if not isinstance(x, str) and np.iterable(x) and len(x) == nrecs:

seqlist[i] = True

if isinstance(x, np.ma.MaskedArray):

if x.ndim > 1:

raise ValueError("Masked arrays must be 1-D")

else:

x = np.asarray(x)

margs.append(x)

masks = [] # list of masks that are True where good

for i, x in enumerate(margs):

if seqlist[i]:

if x.ndim > 1:

continue # Don't try to get nan locations unless 1-D.

if isinstance(x, np.ma.MaskedArray):

masks.append(~np.ma.getmaskarray(x)) # invert the mask

xd = x.data

else:

xd = x

try:

mask = np.isfinite(xd)

if isinstance(mask, np.ndarray):

masks.append(mask)

except Exception: # Fixme: put in tuple of possible exceptions?

pass

if len(masks):

mask = np.logical_and.reduce(masks)

igood = mask.nonzero()[0]

if len(igood) < nrecs:

for i, x in enumerate(margs):

if seqlist[i]:

margs[i] = x[igood]

for i, x in enumerate(margs):

if seqlist[i] and isinstance(x, np.ma.MaskedArray):

margs[i] = x.filled()

return margs

def _combine_masks(*args):

"""

Find all masked and/or non-finite points in a set of arguments,

and return the arguments as masked arrays with a common mask.

Arguments can be in any of 5 categories:

1) 1-D masked arrays

2) 1-D ndarrays

3) ndarrays with more than one dimension

4) other non-string iterables