"""

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

self.missing = missing

self.missingval = missingval

def __call__(self, s):

if s==self.missing: return self.missingval

return s

def is_missing(self, s):

'convert to a datetime or None'

def __init__(self, fmt='%Y-%m-%d', missing='Null', missingval=None):

'use a time.strptime format string for conversion'

converter.__init__(self, missing, missingval)

self.fmt = fmt

def __call__(self, s):

if self.is_missing(s): return self.missingval

tup = time.strptime(s, self.fmt)

'convert to a date or None'

def __init__(self, fmt='%Y-%m-%d', missing='Null', missingval=None):

'use a time.strptime format string for conversion'

converter.__init__(self, missing, missingval)

self.fmt = fmt

def __call__(self, s):

if self.is_missing(s): return self.missingval

tup = time.strptime(s, self.fmt)

'convert to a float or None'

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

converter.__init__(self, missing)

self.missingval = missingval

def __call__(self, s):

if self.is_missing(s): return self.missingval

'convert to an int or None'

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

converter.__init__(self, missing)

def __call__(self, s):

if self.is_missing(s): return self.missingval

"""

def __init__(self, signals):

'signals is a sequence of valid signals'

self.signals = set(signals)

# callbacks is a dict mapping the signal to a dictionary

# mapping callback id to the callback function

self.callbacks = dict([(s, dict()) for s in signals])

self._cid = 0

def _check_signal(self, s):

'make sure s is a valid signal or raise a ValueError'

if s not in self.signals:

signals = list(self.signals)

signals.sort()

raise ValueError('Unknown signal "%s"; valid signals are %s'%(s, signals))

def connect(self, s, func):

"""

self._check_signal(s)

self._cid +=1

self.callbacks[s][self._cid] = func

return self._cid

def disconnect(self, cid):

"""

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

try: del callbackd[cid]

except KeyError: continue

else: return

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

"""

self._check_signal(s)

for func in self.callbacks[s].values():

"""

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)

def __str__(self):

'remove latex formatting from mathtext'

remove = (r'\mathdefault', r'\rm', r'\cal', r'\tt', r'\it', '\\', '{', '}')

s = s[1:-1]

for r in remove: s = s.replace(r,'')

"""

def __init__(self, **kwds):

if hasattr(obj, 'shape'): return 0

try: obj + ''

except (TypeError, ValueError): return 0

"""

if is_string_like(fname):

if fname.endswith('.gz'):

import gzip

fh = gzip.open(fname, flag)

else:

fh = file(fname, flag)

elif hasattr(fname, 'seek'):

fh = fname

else:

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

"""

for item in seq:

if scalarp(item): yield item

else:

for subitem in flatten(item, scalarp):

"""

def _helper(self, data, aux, inplace):

aux.sort()

result = [data[i] for junk, i in aux]

if inplace: data[:] = result

return result

def byItem(self, data, itemindex=None, inplace=1):

if itemindex is None:

if inplace:

data.sort()

result = data

else:

result = data[:]

result.sort()

return result

else:

aux = [(data[i][itemindex], i) for i in range(len(data))]

return self._helper(data, aux, inplace)

def byAttribute(self, data, attributename, inplace=1):

aux = [(getattr(data[i],attributename),i) for i in range(len(data))]

return self._helper(data, aux, inplace)

# a couple of handy synonyms

sort = byItem

"""

def _make_regex(self):

""" Build re object based on the keys of the current dictionary """

return re.compile("|".join(map(re.escape, self.keys())))

def __call__(self, match):

""" Handler invoked for each regex match """

return self[match.group(0)]

def xlat(self, text):

""" Translate text, returns the modified text. """

""" soundex module conforming to Odell-Russell algorithm """

# digits holds the soundex values for the alphabet

soundex_digits = '01230120022455012623010202'

sndx = ''

fc = ''

# Translate letters in name to soundex digits

for c in name.upper():

if c.isalpha():

if not fc: fc = c # Remember first letter

d = soundex_digits[ord(c)-ord('A')]

# Duplicate consecutive soundex digits are skipped

if not sndx or (d != sndx[-1]):

sndx += d

# Replace first digit with first letter

sndx = fc + sndx[1:]

# Remove all 0s from the soundex code

sndx = sndx.replace('0', '')

# Return soundex code truncated or 0-padded to len characters

""" Null objects always and reliably "do nothing." """

def __init__(self, *args, **kwargs): pass

def __call__(self, *args, **kwargs): return self

def __str__(self): return "Null()"

def __repr__(self): return "Null()"

def __nonzero__(self): return 0

def __getattr__(self, name): return self

def __setattr__(self, name, value): return self

try: os.makedirs(newdir, mode)

except OSError, err:

# Reraise the error unless it's about an already existing directory

if err.errno != errno.EEXIST or not os.path.isdir(newdir):

def __init__(self):

self._cache = {}

def __call__(self, path):

result = self._cache.get(path)

if result is None:

realpath = os.path.realpath(path)

stat = os.stat(realpath)

stat_key = (stat.st_ino, stat.st_dev)

result = realpath, stat_key

self._cache[path] = result

'delete all of the keys from the dict d'

for key in keys:

try: del d[key]

""" class that implements a not-yet-full buffer """

def __init__(self,size_max):

self.max = size_max

self.data = []

class __Full:

""" class that implements a full buffer """

def append(self, x):

""" Append an element overwriting the oldest one. """

self.data[self.cur] = x

self.cur = (self.cur+1) % self.max

def get(self):

""" return list of elements in correct order """

return self.data[self.cur:]+self.data[:self.cur]

def append(self,x):

"""append an element at the end of the buffer"""

self.data.append(x)

if len(self.data) == self.max:

self.cur = 0

# Permanently change self's class from non-full to full

self.__class__ = __Full

def get(self):

""" Return a list of elements from the oldest to the newest. """

return self.data

def __get_item__(self, i):

"""Python equivalent to the enumerate builtin function

for i in range(len(seq)):

"""Python equivalent to the enumerate builtin function

for i in range(len(seq)-1,-1,-1):

"""Python equivalent to itertools.izip

iterables = map(iter, iterables)

while iterables:

result = [i.next() for i in iterables]

"""seq is a list of words. Return the index into seq such that

sLen = 0

# todo: use Alex's xrange pattern from the cbook for efficiency

for (word, ind) in zip(seq, range(len(seq))):

sLen += len(word) + 1 # +1 to account for the len(' ')

if sLen>=N: return ind

'wrap text with prefix at length cols'

pad = ' '*len(prefix.expandtabs())

available = cols - len(pad)

seq = text.split(' ')

Nseq = len(seq)

ind = 0

lines = []

while ind<Nseq:

lastInd = ind

ind += get_split_ind(seq[ind:], available)

lines.append(seq[lastInd:ind])

# add the prefix to the first line, pad with spaces otherwise

ret = prefix + ' '.join(lines[0]) + '\n'

for line in lines[1:]:

ret += pad + ' '.join(line) + '\n'

"""

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

"""

import os.path, fnmatch

# Expand patterns from semicolon-separated string to list

pattern_list = patterns.split(';')

# Collect input and output arguments into one bunch

class Bunch:

def __init__(self, **kwds): self.__dict__.update(kwds)

arg = Bunch(recurse=recurse, pattern_list=pattern_list,

return_folders=return_folders, results=[])

def visit(arg, dirname, files):

# Append to arg.results all relevant files (and perhaps folders)

for name in files:

fullname = os.path.normpath(os.path.join(dirname, name))

if arg.return_folders or os.path.isfile(fullname):

for pattern in arg.pattern_list:

if fnmatch.fnmatch(name, pattern):

arg.results.append(fullname)

break

# Block recursion if recursion was disallowed

if not arg.recurse: files[:]=[]

os.path.walk(root, visit, arg)

"""

files = []

for arg in args:

if os.path.isfile(arg):

files.append(arg)

continue

if os.path.isdir(arg):

newfiles = listFiles(arg, recurse=1, return_folders=1)

files.extend(newfiles)

"Break up the seq into num tuples"

start = 0

while 1:

item = seq[start:start+num]

if not len(item): break

yield item

sh = StringIO.StringIO()

if s is not None: print >>sh, s

traceback.print_exc(file=sh)

"""

if len(seq)<2: return True

val = seq[0]

for i in xrange(1, len(seq)):

thisval = seq[i]

if thisval != val: return False

#return true if all elements of seq are true. If seq is empty return false

if not len(seq): return False

for val in seq:

if not val: return False

#return true if one element of seq is true. If seq is empty return false

if not len(seq): return False

for val in seq:

if val: return True

"""

"""

if len(args)==1:

key = args[0]

val = d[key]

del d[key]

elif len(args)==2:

key, default = args

val = d.get(key, default)

try: del d[key]

except KeyError: pass

"""

def __init__(self, maxsize):

dict.__init__(self)

self.maxsize = maxsize

self._killkeys = []

def __setitem__(self, k, v):

if len(self)>=self.maxsize:

del self[self._killkeys[0]]

del self._killkeys[0]

dict.__setitem__(self, k, v)

"""

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 forward(self):

'move the position forward and return the current element'

N = len(self._elements)

if self._pos<N-1: self._pos += 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):

"""

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

self._elements.append(o)

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

return self()

def home(self):

'push the first element onto the top of the stack'

if not len(self._elements): return

self.push(self._elements[0])

return self()

def empty(self):

return len(self._elements)==0

def clear(self):

'empty the stack'

self._pos = -1

self._elements = []

def bubble(self, o):

"""

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 thiso in bubbles:

self.push(o)

return o

def remove(self, o):

'remove element 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: continue

"""

if case:

names = [(name,name) for name in dir(o) if is_string_like(name)]

else:

names = [(name.lower(), name) for name in dir(o) if is_string_like(name)]

match = match.lower()

'return the memory consumed by process'

pid = os.getpid()

if sys.platform=='sunos5':

a2 = os.popen('ps -p %d -o osz' % pid).readlines()

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

elif sys.platform.startswith('linux'):

a2 = os.popen('ps -p %d -o rss,sz' % pid).readlines()

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

elif sys.platform.startswith('darwin'):

a2 = os.popen('ps -p %d -o rss,vsz' % pid).readlines()

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

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

def __init__(self, nmax=20000):

self._nmax = nmax

self._mem = npy.zeros((self._nmax,), npy.int32)

self.clear()

def clear(self):

self._n = 0

self._overflow = False

def __call__(self):

mem = report_memory()

if self._n < self._nmax:

self._mem[self._n] = mem

self._n += 1

else:

self._overflow = True

return mem

def report(self, segments=4):

n = self._n

segments = min(n, segments)

dn = int(n/segments)

ii = range(0, n, dn)

ii[-1] = n-1

print

print 'memory report: i, mem, dmem, dmem/nloops'

print 0, self._mem[0]

for i in range(1, len(ii)):

di = ii[i] - ii[i-1]

if di == 0:

continue

dm = self._mem[ii[i]] - self._mem[ii[i-1]]

print '%5d %5d %3d %8.3f' % (ii[i], self._mem[ii[i]],

dm, dm / float(di))

if self._overflow:

print "Warning: array size was too small for the number of calls."

def xy(self, i0=0, isub=1):

x = npy.arange(i0, self._n, isub)

return x, self._mem[i0:self._n:isub]

def plot(self, i0=0, isub=1, fig=None):

if fig is None:

from pylab import figure, show

fig = figure()

ax = fig.add_subplot(111)

ax.plot(*self.xy(i0, isub))

"""

import gc

from types import FrameType

def print_path(path):

for i, step in enumerate(path):

# next "wraps around"

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

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

if isinstance(step, dict):

for key, val in step.items():

if val is next:

outstream.write("[%s]" % repr(key))

break

if key is next:

outstream.write("[key] = %s" % repr(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, 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("Examining: %r\n" % (obj,))

"""

"""

def __init__(self, init=[]):

mapping = self._mapping = {}

for x in init:

mapping[x] = [x]

def __contains__(self, item):

return item in self._mapping