from __future__ import (absolute_import, division, print_function,

unicode_literals)

import six

from six.moves import xrange, zip

from itertools import repeat

import datetime

import errno

from functools import reduce

import glob

import gzip

import io

import locale

import os

import re

import sys

import threading

import time

import traceback

import types

import warnings

from weakref import ref, WeakKeyDictionary

import numpy as np

import numpy.ma as ma

class MatplotlibDeprecationWarning(UserWarning):

pass

mplDeprecation = MatplotlibDeprecationWarning

def _generate_deprecation_message(since, message='', name='',

return message

def warn_deprecated(

warnings.warn(message, mplDeprecation, stacklevel=1)

def deprecated(since, message='', name='', alternative='', pending=False,

return deprecate

def unicode_safe(s):

return s

class converter(object):

return not s.strip() or s == self.missing

class tostr(converter):

'convert to string or None'

def __init__(self, missing='Null', missingval=''):

converter.__init__(self, missing=missing, missingval=missingval)

class todatetime(converter):

return datetime.datetime(*tup[:6])

class todate(converter):

return datetime.date(*tup[:3])

class tofloat(converter):

return float(s)

class toint(converter):

return int(s)

class _BoundMethodProxy(object):

return self._hash

class CallbackRegistry(object):

self._remove_proxy(proxy)

class Scheduler(threading.Thread):

self._stopped = True

class Timeout(Scheduler):

break

class Idle(Scheduler):

break

class silent_list(list):

self.extend(state['seq'])

def strip_math(s):

return s

class Bunch(object):

in keys])

def unique(x):

'Return a list of unique elements of *x*'

return list(six.iterkeys(dict([(val, 1) for val in x])))

def iterable(obj):

return True

def is_string_like(obj):

return True

def is_sequence_of_strings(obj):

return True

def is_writable_file_like(obj):

'return true if *obj* looks like a file object with a *write* method'

return hasattr(obj, 'write') and six.callable(obj.write)

def file_requires_unicode(x):

return False

def is_scalar(obj):

'return true if *obj* is not string like and is not iterable'

return not is_string_like(obj) and not iterable(obj)

def is_numlike(obj):

return True

def to_filehandle(fname, flag='rU', return_opened=False):

return fh

def is_scalar_or_string(val):

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

return is_string_like(val) or not iterable(val)

def _string_to_bool(s):

raise ValueError("string argument must be either 'on' or 'off'")

def get_sample_data(fname, asfileobj=True):

return path

def flatten(seq, scalarp=is_scalar_or_string):

yield subitem

class Sorter(object):

__call__ = byItem

class Xlator(dict):

return self._make_regex().sub(self, text)

def soundex(name, len=4):

return (sndx + (len * '0'))[:len]

class Null(object):