from __future__ import print_function

import datetime

import errno

from functools import reduce

import glob

import gzip

import io

import locale

import os

import re

import subprocess

import sys

import threading

import time

import traceback

import warnings

from weakref import ref, WeakKeyDictionary

import numpy as np

import numpy.ma as ma

if sys.version_info[0] >= 3:

import types

else:

import new

if sys.version_info[0] >= 3:

def unicode_safe(s):

return s

else:

def unicode_safe(s):

return unicode(s, preferredencoding)

class converter:

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 not self.__eq__(other)

class CallbackRegistry:

proxy(*args, **kwargs)

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:

in keys])

def unique(x):

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

return dict([(val, 1) for val in x]).keys()

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 callable(obj.write)

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 get_sample_data(fname, asfileobj=True):

return path

def flatten(seq, scalarp=is_scalar_or_string):

yield subitem

class Sorter:

__call__ = byItem

class Xlator(dict):

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

def soundex(name, len=4):

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

class Null:

return self

def mkdirs(newdir, mode=0o777):

raise

class GetRealpathAndStat:

return result

get_realpath_and_stat = GetRealpathAndStat()

def dict_delall(d, keys):

pass

class RingBuffer:

return self.data[i % len(self.data)]

def get_split_ind(seq, N):

return len(seq)

def wrap(prefix, text, cols):

return ret

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

_dedent_regex = {}

def dedent(s):

return result

def listFiles(root, patterns='*', recurse=1, return_folders=0):

return results

def get_recursive_filelist(args):

return [f for f in files if not os.path.islink(f)]

def pieces(seq, num=2):

start += num

def exception_to_str(s=None):

return sh.getvalue()

def allequal(seq):

return True