"""

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 gzip

import itertools

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

import numpy as np

import matplotlib

from matplotlib import _api, _c_internal_utils

from matplotlib._api.deprecation import (

MatplotlibDeprecationWarning, mplDeprecation)

@_api.deprecated("3.4")

def deprecated(*args, **kwargs):

return _api.deprecated(*args, **kwargs)

@_api.deprecated("3.4")

def warn_deprecated(*args, **kwargs):

_api.warn_deprecated(*args, **kwargs)

def _get_running_interactive_framework():

"""

Return the interactive framework whose event loop is currently running, if

any, or "headless" if no event loop can be started, or None.

Returns

-------

Optional[str]

One of the following values: "qt5", "qt4", "gtk3", "wx", "tk",

"macosx", "headless", ``None``.

"""

QtWidgets = (sys.modules.get("PyQt5.QtWidgets")

or sys.modules.get("PySide2.QtWidgets"))

if QtWidgets and QtWidgets.QApplication.instance():

return "qt5"

QtGui = (sys.modules.get("PyQt4.QtGui")

or sys.modules.get("PySide.QtGui"))

if QtGui and QtGui.QApplication.instance():

return "qt4"

Gtk = sys.modules.get("gi.repository.Gtk")

if Gtk and Gtk.main_level():

return "gtk3"

wx = sys.modules.get("wx")

if wx and wx.GetApp():

return "wx"

tkinter = sys.modules.get("tkinter")

if tkinter:

codes = {tkinter.mainloop.__code__, tkinter.Misc.mainloop.__code__}

for frame in sys._current_frames().values():

while frame:

if frame.f_code in codes:

return "tk"

frame = frame.f_back

if 'matplotlib.backends._macosx' in sys.modules:

if sys.modules["matplotlib.backends._macosx"].event_loop_is_running():

return "macosx"

if not _c_internal_utils.display_is_valid():

return "headless"

return None

def _exception_printer(exc):

if _get_running_interactive_framework() in ["headless", None]:

raise exc

else:

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)

def _weak_or_strong_ref(func, callback):

"""

Return a `WeakMethod` wrapping *func* if possible, else a `_StrongRef`.

"""

try:

return weakref.WeakMethod(func, callback)

except TypeError:

return _StrongRef(func)

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 not None, *exception_handler* must be a function that takes an

`Exception` as single parameter. It gets called with any `Exception`

raised by the callbacks during `CallbackRegistry.process`, and may

either re-raise the exception or handle it in another manner.

The default handler prints the exception (with `traceback.print_exc`) if

an interactive event loop is running; it re-raises the exception if no

interactive event loop is running.

"""

# We maintain two mappings:

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

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

def __init__(self, exception_handler=_exception_printer):

self.exception_handler = exception_handler

self.callbacks = {}

self._cid_gen = itertools.count()

self._func_cid_map = {}

# A hidden variable that marks cids that need to be pickled.

self._pickled_cids = set()

def __getstate__(self):

return {

**vars(self),

# In general, callbacks may not be pickled, so we just drop them,

# unless directed otherwise by self._pickled_cids.

"callbacks": {s: {cid: proxy() for cid, proxy in d.items()

if cid in self._pickled_cids}

for s, d in self.callbacks.items()},

# It is simpler to reconstruct this from callbacks in __setstate__.

"_func_cid_map": None,

}

def __setstate__(self, state):

vars(self).update(state)

self.callbacks = {

s: {cid: _weak_or_strong_ref(func, self._remove_proxy)

for cid, func in d.items()}

for s, d in self.callbacks.items()}

self._func_cid_map = {

s: {proxy: cid for cid, proxy in d.items()}

for s, d in self.callbacks.items()}

@_api.rename_parameter("3.4", "s", "signal")

def connect(self, signal, func):

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

self._func_cid_map.setdefault(signal, {})

proxy = _weak_or_strong_ref(func, self._remove_proxy)

if proxy in self._func_cid_map[signal]:

return self._func_cid_map[signal][proxy]

cid = next(self._cid_gen)

self._func_cid_map[signal][proxy] = cid

self.callbacks.setdefault(signal, {})

self.callbacks[signal][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, proxy_to_cid in list(self._func_cid_map.items()):

cid = proxy_to_cid.pop(proxy, None)

if cid is not None:

del self.callbacks[signal][cid]

self._pickled_cids.discard(cid)

break

else:

# Not found

return

# Clean up empty dicts

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*.

No error is raised if such a callback does not exist.

"""

self._pickled_cids.discard(cid)

# Clean up callbacks

for signal, cid_to_proxy in list(self.callbacks.items()):

proxy = cid_to_proxy.pop(cid, None)

if proxy is not None:

break

else:

# Not found

return

proxy_to_cid = self._func_cid_map[signal]

for current_proxy, current_cid in list(proxy_to_cid.items()):

if current_cid == cid:

assert proxy is current_proxy

del proxy_to_cid[current_proxy]

# Clean up empty dicts

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

del self.callbacks[signal]

del self._func_cid_map[signal]

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>

If ``self.type`` is None, the type name is obtained from the first item in

the list (if any).

"""

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

self.type = type

if seq is not None:

self.extend(seq)

def __repr__(self):

if self.type is not None or len(self) != 0:

tp = self.type if self.type is not None else type(self[0]).__name__

return f"<a list of {len(self)} {tp} objects>"

else:

return "<an empty list>"

@_api.deprecated("3.3")

class IgnoredKeywordWarning(UserWarning):

"""

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

by Matplotlib.

"""

pass

@_api.deprecated("3.3", alternative="normalize_kwargs")

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

-------

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.

"""

return _local_over_kwdict(local_var, kwargs, *keys, IgnoredKeywordWarning)

def _local_over_kwdict(

local_var, kwargs, *keys, warning_cls=MatplotlibDeprecationWarning):

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:

_api.warn_external(f'"{key}" keyword argument will be ignored',

warning_cls)

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

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

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 "U" in flag:

_api.warn_deprecated(

"3.3", message="Passing a flag containing 'U' to to_filehandle() "

"is deprecated since %(since)s and will be removed %(removal)s.")

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

if isinstance(fname, str):

if fname.endswith('.gz'):

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

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 path-likes."""

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, *, np_load=False):

"""

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

:file:`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. If the

filename ends with .npy or .npz, *asfileobj* is True, and *np_load* is

True, the file is loaded with `numpy.load`. *np_load* currently defaults

to False but will default to True in a future release.

"""

path = _get_data_path('sample_data', fname)

if asfileobj:

suffix = path.suffix.lower()

if suffix == '.gz':

return gzip.open(path)

elif suffix in ['.npy', '.npz']:

if np_load:

return np.load(path)

else:

_api.warn_deprecated(

"3.3", message="In a future release, get_sample_data "

"will automatically load numpy arrays. Set np_load to "

"True to get the array and suppress this warning. Set "

"asfileobj to False to get the path to the data file and "

"suppress this warning.")

return path.open('rb')

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 `pathlib.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)

@_api.deprecated("3.3", alternative="os.path.realpath and os.stat")

@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 = {}

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 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 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 all references of *o* to the top of the stack, and return it.

Raises

------

ValueError

If *o* is not in the stack.

"""

if o not in self._elements:

raise ValueError('Given element not contained in the stack')

old_elements = self._elements.copy()

self.clear()

top_elements = []

for elem in old_elements:

if elem == o:

top_elements.append(elem)

else:

self.push(elem)

for _ in top_elements:

self.push(o)

return o

def remove(self, o):

"""

Remove *o* from the stack.

Raises

------

ValueError

If *o* is not in the stack.

"""

if o not in self._elements:

raise ValueError('Given element not contained in the stack')

old_elements = self._elements.copy()

self.clear()

for elem in old_elements:

if elem != o:

self.push(elem)

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 as err:

raise NotImplementedError(

"report_memory works on %s only if "

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

) from err

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

def safe_masked_invalid(x, copy=False):

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

if not x.dtype.isnative:

# If we have already made a copy, do the byteswap in place, else make a

# copy with the byte order swapped.

x = x.byteswap(inplace=copy).newbyteorder('N') # Swap to native order.

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:

"""

A disjoint-set data structure.

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.

Examples

--------

>>> 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)

>>> list(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 `numpy.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?