#!/usr/bin/env python

"""

General Utilities

(part of web.py)

"""

__all__ = [

  "Storage", "storage", "storify", 

  "Counter", "counter",

  "iters", 

  "rstrips", "lstrips", "strips", 

  "safeunicode", "safestr", "utf8",

  "TimeoutError", "timelimit",

  "Memoize", "memoize",

  "re_compile", "re_subm",

  "group", "uniq", "iterview",

  "IterBetter", "iterbetter",

  "safeiter", "safewrite",

  "dictreverse", "dictfind", "dictfindall", "dictincr", "dictadd",

  "requeue", "restack",

  "listget", "intget", "datestr",

  "numify", "denumify", "commify", "dateify",

  "nthstr", "cond",

  "CaptureStdout", "capturestdout", "Profile", "profile",

  "tryall",

  "ThreadedDict", "threadeddict",

  "autoassign",

  "to36",

  "safemarkdown",

  "sendmail"

]

import re, sys, time, threading, itertools, traceback, os

try:

    import subprocess

except ImportError: 

    subprocess = None

try: import datetime

except ImportError: pass

try: set

except NameError:

    from sets import Set as set

try:

    from threading import local as threadlocal

except ImportError:

    from python23 import threadlocal

class Storage(dict):

    """

    A Storage object is like a dictionary except `obj.foo` can be used

    in addition to `obj['foo']`.

        >>> o = storage(a=1)

        >>> o.a

        1

        >>> o['a']

        1

        >>> o.a = 2

        >>> o['a']

        2

        >>> del o.a

        >>> o.a

        Traceback (most recent call last):

            ...

        AttributeError: 'a'

    """

    def __getattr__(self, key): 

        try:

            return self[key]

        except KeyError, k:

            raise AttributeError, k

    def __setattr__(self, key, value): 

        self[key] = value

    def __delattr__(self, key):

        try:

            del self[key]

        except KeyError, k:

            raise AttributeError, k

    def __repr__(self):     

        return '<Storage ' + dict.__repr__(self) + '>'

storage = Storage

def storify(mapping, *requireds, **defaults):

    """

    Creates a `storage` object from dictionary `mapping`, raising `KeyError` if

    d doesn't have all of the keys in `requireds` and using the default 

    values for keys found in `defaults`.

    For example, `storify({'a':1, 'c':3}, b=2, c=0)` will return the equivalent of

    `storage({'a':1, 'b':2, 'c':3})`.

    If a `storify` value is a list (e.g. multiple values in a form submission), 

    `storify` returns the last element of the list, unless the key appears in 

    `defaults` as a list. Thus:

        >>> storify({'a':[1, 2]}).a

        2

        >>> storify({'a':[1, 2]}, a=[]).a

        [1, 2]

        >>> storify({'a':1}, a=[]).a

        [1]

        >>> storify({}, a=[]).a

        []

    Similarly, if the value has a `value` attribute, `storify will return _its_

    value, unless the key appears in `defaults` as a dictionary.

        >>> storify({'a':storage(value=1)}).a

        1

        >>> storify({'a':storage(value=1)}, a={}).a

        <Storage {'value': 1}>

        >>> storify({}, a={}).a

        {}

    Optionally, keyword parameter `_unicode` can be passed to convert all values to unicode.

        >>> storify({'x': 'a'}, _unicode=True)

        <Storage {'x': u'a'}>

        >>> storify({'x': storage(value='a')}, x={}, _unicode=True)

        <Storage {'x': <Storage {'value': 'a'}>}>

        >>> storify({'x': storage(value='a')}, _unicode=True)

        <Storage {'x': u'a'}>

    """

    _unicode = defaults.pop('_unicode', False)

    # if _unicode is callable object, use it convert a string to unicode.

    to_unicode = safeunicode

    if _unicode is not False and hasattr(_unicode, "__call__"):

        to_unicode = _unicode

    def unicodify(s):

        if _unicode and isinstance(s, str): return to_unicode(s)

        else: return s

    def getvalue(x):

        if hasattr(x, 'file') and hasattr(x, 'value'):

            return x.value

        elif hasattr(x, 'value'):

            return unicodify(x.value)

        else:

            return unicodify(x)

    stor = Storage()

    for key in requireds + tuple(mapping.keys()):

        value = mapping[key]

        if isinstance(value, list):

            if isinstance(defaults.get(key), list):

                value = [getvalue(x) for x in value]

            else:

                value = value[-1]

        if not isinstance(defaults.get(key), dict):

            value = getvalue(value)

        if isinstance(defaults.get(key), list) and not isinstance(value, list):

            value = [value]

        setattr(stor, key, value)

    for (key, value) in defaults.iteritems():

        result = value

        if hasattr(stor, key): 

            result = stor[key]

        if value == () and not isinstance(result, tuple): 

            result = (result,)

        setattr(stor, key, result)

    return stor

class Counter(storage):

    """Keeps count of how many times something is added.

        >>> c = counter()

        >>> c.add('x')

        >>> c.add('x')

        >>> c.add('x')

        >>> c.add('x')

        >>> c.add('x')

        >>> c.add('y')

        >>> c

        <Counter {'y': 1, 'x': 5}>

        >>> c.most()

        ['x']

    """

    def add(self, n):

        self.setdefault(n, 0)

        self[n] += 1

    def most(self):

        """Returns the keys with maximum count."""

        m = max(self.itervalues())

        return [k for k, v in self.iteritems() if v == m]

    def least(self):

        """Returns the keys with mininum count."""

        m = min(self.itervalues())

        return [k for k, v in self.iteritems() if v == m]

    def percent(self, key):

       """Returns what percentage a certain key is of all entries.

           >>> c = counter()

           >>> c.add('x')

           >>> c.add('x')

           >>> c.add('x')

           >>> c.add('y')

           >>> c.percent('x')

           0.75

           >>> c.percent('y')

           0.25

       """

       return float(self[key])/sum(self.values())

    def sorted_keys(self):

        """Returns keys sorted by value.

             >>> c = counter()

             >>> c.add('x')

             >>> c.add('x')

             >>> c.add('y')

             >>> c.sorted_keys()

             ['x', 'y']

        """

        return sorted(self.keys(), key=lambda k: self[k], reverse=True)

    def sorted_values(self):

        """Returns values sorted by value.

            >>> c = counter()

            >>> c.add('x')

            >>> c.add('x')

            >>> c.add('y')

            >>> c.sorted_values()

            [2, 1]

        """

        return [self[k] for k in self.sorted_keys()]

    def sorted_items(self):

        """Returns items sorted by value.

            >>> c = counter()

            >>> c.add('x')

            >>> c.add('x')

            >>> c.add('y')

            >>> c.sorted_items()

            [('x', 2), ('y', 1)]

        """

        return [(k, self[k]) for k in self.sorted_keys()]

    def __repr__(self):

        return '<Counter ' + dict.__repr__(self) + '>'

counter = Counter

iters = [list, tuple]

import __builtin__

if hasattr(__builtin__, 'set'):

    iters.append(set)

if hasattr(__builtin__, 'frozenset'):

    iters.append(set)

if sys.version_info < (2,6): # sets module deprecated in 2.6

    try:

        from sets import Set

        iters.append(Set)

    except ImportError: 

        pass

class _hack(tuple): pass

iters = _hack(iters)

iters.__doc__ = """

A list of iterable items (like lists, but not strings). Includes whichever

of lists, tuples, sets, and Sets are available in this version of Python.

"""

def _strips(direction, text, remove):

    if isinstance(remove, iters):

        for subr in remove:

            text = _strips(direction, text, subr)

        return text

    if direction == 'l': 

        if text.startswith(remove): 

            return text[len(remove):]

    elif direction == 'r':

        if text.endswith(remove):   

            return text[:-len(remove)]

    else: 

        raise ValueError, "Direction needs to be r or l."

    return text

def rstrips(text, remove):

    """

    removes the string `remove` from the right of `text`

        >>> rstrips("foobar", "bar")

        'foo'

    """

    return _strips('r', text, remove)

def lstrips(text, remove):

    """

    removes the string `remove` from the left of `text`

        >>> lstrips("foobar", "foo")

        'bar'

        >>> lstrips('http://foo.org/', ['http://', 'https://'])

        'foo.org/'

        >>> lstrips('FOOBARBAZ', ['FOO', 'BAR'])

        'BAZ'

        >>> lstrips('FOOBARBAZ', ['BAR', 'FOO'])

        'BARBAZ'

    """

    return _strips('l', text, remove)

def strips(text, remove):

    """

    removes the string `remove` from the both sides of `text`

        >>> strips("foobarfoo", "foo")

        'bar'

    """

    return rstrips(lstrips(text, remove), remove)

def safeunicode(obj, encoding='utf-8'):

    r"""

    Converts any given object to unicode string.

        >>> safeunicode('hello')

        u'hello'

        >>> safeunicode(2)

        u'2'

        >>> safeunicode('\xe1\x88\xb4')

        u'\u1234'

    """

    t = type(obj)

    if t is unicode:

        return obj

    elif t is str:

        return obj.decode(encoding)

    elif t in [int, float, bool]:

        return unicode(obj)

    elif hasattr(obj, '__unicode__') or isinstance(obj, unicode):

        return unicode(obj)

    else:

        return str(obj).decode(encoding)

def safestr(obj, encoding='utf-8'):

    r"""

    Converts any given object to utf-8 encoded string. 

        >>> safestr('hello')

        'hello'

        >>> safestr(u'\u1234')

        '\xe1\x88\xb4'

        >>> safestr(2)

        '2'

    """

    if isinstance(obj, unicode):

        return obj.encode(encoding)

    elif isinstance(obj, str):

        return obj

    elif hasattr(obj, 'next'): # iterator

        return itertools.imap(safestr, obj)

    else:

        return str(obj)

# for backward-compatibility

utf8 = safestr

class TimeoutError(Exception): pass

def timelimit(timeout):

    """

    A decorator to limit a function to `timeout` seconds, raising `TimeoutError`

    if it takes longer.

        >>> import time

        >>> def meaningoflife():

        ...     time.sleep(.2)

        ...     return 42

        >>> 

        >>> timelimit(.1)(meaningoflife)()

        Traceback (most recent call last):

            ...

        TimeoutError: took too long

        >>> timelimit(1)(meaningoflife)()

        42

    _Caveat:_ The function isn't stopped after `timeout` seconds but continues 

    executing in a separate thread. (There seems to be no way to kill a thread.)

    inspired by <http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/473878>

    """

    def _1(function):

        def _2(*args, **kw):

            class Dispatch(threading.Thread):

                def __init__(self):

                    threading.Thread.__init__(self)

                    self.result = None

                    self.error = None

                    self.setDaemon(True)

                    self.start()

                def run(self):

                    try:

                        self.result = function(*args, **kw)

                    except:

                        self.error = sys.exc_info()

            c = Dispatch()

            c.join(timeout)

            if c.isAlive():

                raise TimeoutError, 'took too long'

            if c.error:

                raise c.error[0], c.error[1]

            return c.result

        return _2

    return _1

class Memoize:

    """

    'Memoizes' a function, caching its return values for each input.

    If `expires` is specified, values are recalculated after `expires` seconds.

    If `background` is specified, values are recalculated in a separate thread.

        >>> calls = 0

        >>> def howmanytimeshaveibeencalled():

        ...     global calls

        ...     calls += 1

        ...     return calls

        >>> fastcalls = memoize(howmanytimeshaveibeencalled)

        >>> howmanytimeshaveibeencalled()

        1

        >>> howmanytimeshaveibeencalled()

        2

        >>> fastcalls()

        3

        >>> fastcalls()

        3

        >>> import time

        >>> fastcalls = memoize(howmanytimeshaveibeencalled, .1, background=False)

        >>> fastcalls()

        4

        >>> fastcalls()

        4

        >>> time.sleep(.2)

        >>> fastcalls()

        5

        >>> def slowfunc():

        ...     time.sleep(.1)

        ...     return howmanytimeshaveibeencalled()

        >>> fastcalls = memoize(slowfunc, .2, background=True)

        >>> fastcalls()

        6

        >>> timelimit(.05)(fastcalls)()

        6

        >>> time.sleep(.2)

        >>> timelimit(.05)(fastcalls)()

        6

        >>> timelimit(.05)(fastcalls)()

        6

        >>> time.sleep(.2)

        >>> timelimit(.05)(fastcalls)()

        7

        >>> fastcalls = memoize(slowfunc, None, background=True)

        >>> threading.Thread(target=fastcalls).start()

        >>> time.sleep(.01)

        >>> fastcalls()

        9

    """

    def __init__(self, func, expires=None, background=True): 

        self.func = func

        self.cache = {}

        self.expires = expires

        self.background = background

        self.running = {}

    def __call__(self, *args, **keywords):

        key = (args, tuple(keywords.items()))

        if not self.running.get(key):

            self.running[key] = threading.Lock()

        def update(block=False):

            if self.running[key].acquire(block):

                try:

                    self.cache[key] = (self.func(*args, **keywords), time.time())

                finally:

                    self.running[key].release()

        if key not in self.cache: 

            update(block=True)

        elif self.expires and (time.time() - self.cache[key][1]) > self.expires:

            if self.background:

                threading.Thread(target=update).start()

            else:

                update()

        return self.cache[key][0]

memoize = Memoize

re_compile = memoize(re.compile) #@@ threadsafe?

re_compile.__doc__ = """

A memoized version of re.compile.

"""

class _re_subm_proxy:

    def __init__(self): 

        self.match = None

    def __call__(self, match): 

        self.match = match

        return ''

def re_subm(pat, repl, string):

    """

    Like re.sub, but returns the replacement _and_ the match object.

        >>> t, m = re_subm('g(oo+)fball', r'f\\1lish', 'goooooofball')

        >>> t

        'foooooolish'

        >>> m.groups()

        ('oooooo',)

    """

    compiled_pat = re_compile(pat)

    proxy = _re_subm_proxy()

    compiled_pat.sub(proxy.__call__, string)

    return compiled_pat.sub(repl, string), proxy.match

def group(seq, size): 

    """

    Returns an iterator over a series of lists of length size from iterable.

        >>> list(group([1,2,3,4], 2))

        [[1, 2], [3, 4]]

        >>> list(group([1,2,3,4,5], 2))

        [[1, 2], [3, 4], [5]]

    """

    def take(seq, n):

        for i in xrange(n):

            yield seq.next()

    if not hasattr(seq, 'next'):  

        seq = iter(seq)

    while True: 

        x = list(take(seq, size))

        if x:

            yield x

        else:

            break

def uniq(seq, key=None):

    """

    Removes duplicate elements from a list while preserving the order of the rest.

        >>> uniq([9,0,2,1,0])

        [9, 0, 2, 1]

    The value of the optional `key` parameter should be a function that

    takes a single argument and returns a key to test the uniqueness.

        >>> uniq(["Foo", "foo", "bar"], key=lambda s: s.lower())

        ['Foo', 'bar']

    """

    key = key or (lambda x: x)

    seen = set()

    result = []

    for v in seq:

        k = key(v)

        if k in seen:

            continue

        seen.add(k)

        result.append(v)

    return result

def iterview(x):

   """

   Takes an iterable `x` and returns an iterator over it

   which prints its progress to stderr as it iterates through.

   """

   WIDTH = 70

   def plainformat(n, lenx):

       return '%5.1f%% (%*d/%d)' % ((float(n)/lenx)*100, len(str(lenx)), n, lenx)

   def bars(size, n, lenx):

       val = int((float(n)*size)/lenx + 0.5)

       if size - val:

           spacing = ">" + (" "*(size-val))[1:]

       else:

           spacing = ""

       return "[%s%s]" % ("="*val, spacing)

   def eta(elapsed, n, lenx):

       if n == 0:

           return '--:--:--'

       if n == lenx:

           secs = int(elapsed)

       else:

           secs = int((elapsed/n) * (lenx-n))

       mins, secs = divmod(secs, 60)

       hrs, mins = divmod(mins, 60)

       return '%02d:%02d:%02d' % (hrs, mins, secs)

   def format(starttime, n, lenx):

       out = plainformat(n, lenx) + ' '

       if n == lenx:

           end = '     '

       else:

           end = ' ETA '

       end += eta(time.time() - starttime, n, lenx)

       out += bars(WIDTH - len(out) - len(end), n, lenx)

       out += end

       return out

   starttime = time.time()

   lenx = len(x)

   for n, y in enumerate(x):

       sys.stderr.write('\r' + format(starttime, n, lenx))

       yield y

   sys.stderr.write('\r' + format(starttime, n+1, lenx) + '\n')

class IterBetter:

    """

    Returns an object that can be used as an iterator 

    but can also be used via __getitem__ (although it 

    cannot go backwards -- that is, you cannot request 

    `iterbetter[0]` after requesting `iterbetter[1]`).

        >>> import itertools

        >>> c = iterbetter(itertools.count())

        >>> c[1]

        1

        >>> c[5]

        5

        >>> c[3]

        Traceback (most recent call last):

            ...

        IndexError: already passed 3

    For boolean test, IterBetter peeps at first value in the itertor without effecting the iteration.

        >>> c = iterbetter(iter(range(5)))

        >>> bool(c)

        True

        >>> list(c)

        [0, 1, 2, 3, 4]

        >>> c = iterbetter(iter([]))

        >>> bool(c)

        False

        >>> list(c)

        []

    """

    def __init__(self, iterator): 

        self.i, self.c = iterator, 0

    def __iter__(self): 

        if hasattr(self, "_head"):

            yield self._head

        while 1:    

            yield self.i.next()

            self.c += 1

    def __getitem__(self, i):

        #todo: slices

        if i < self.c: 

            raise IndexError, "already passed "+str(i)

        try:

            while i > self.c: 

                self.i.next()

                self.c += 1

            # now self.c == i

            self.c += 1

            return self.i.next()

        except StopIteration: 

            raise IndexError, str(i)

    def __nonzero__(self):

        if hasattr(self, "__len__"):

            return len(self) != 0

        elif hasattr(self, "_head"):

            return True

        else:

            try:

                self._head = self.i.next()

            except StopIteration:

                return False

            else:

                return True

iterbetter = IterBetter

def safeiter(it, cleanup=None, ignore_errors=True):

    """Makes an iterator safe by ignoring the exceptions occured during the iteration.

    """

    def next():

        while True:

            try:

                return it.next()

            except StopIteration:

                raise

            except:

                traceback.print_exc()

    it = iter(it)

    while True:

        yield next()

def safewrite(filename, content):

    """Writes the content to a temp file and then moves the temp file to 

    given filename to avoid overwriting the existing file in case of errors.

    """

    f = file(filename + '.tmp', 'w')

    f.write(content)

    f.close()

    os.rename(f.name, filename)

def dictreverse(mapping):

    """

    Returns a new dictionary with keys and values swapped.

        >>> dictreverse({1: 2, 3: 4})

        {2: 1, 4: 3}

    """

    return dict([(value, key) for (key, value) in mapping.iteritems()])

def dictfind(dictionary, element):

    """

    Returns a key whose value in `dictionary` is `element` 

    or, if none exists, None.

        >>> d = {1:2, 3:4}

        >>> dictfind(d, 4)

        3

        >>> dictfind(d, 5)

    """

    for (key, value) in dictionary.iteritems():

        if element is value: 

            return key

def dictfindall(dictionary, element):

    """

    Returns the keys whose values in `dictionary` are `element`

    or, if none exists, [].

        >>> d = {1:4, 3:4}

        >>> dictfindall(d, 4)

        [1, 3]

        >>> dictfindall(d, 5)

        []

    """

    res = []

    for (key, value) in dictionary.iteritems():

        if element is value:

            res.append(key)

    return res

def dictincr(dictionary, element):

    """

    Increments `element` in `dictionary`, 

    setting it to one if it doesn't exist.

        >>> d = {1:2, 3:4}

        >>> dictincr(d, 1)

        3

        >>> d[1]

        3

        >>> dictincr(d, 5)

        1

        >>> d[5]

        1

    """

    dictionary.setdefault(element, 0)

    dictionary[element] += 1

    return dictionary[element]

def dictadd(*dicts):

    """

    Returns a dictionary consisting of the keys in the argument dictionaries.

    If they share a key, the value from the last argument is used.

        >>> dictadd({1: 0, 2: 0}, {2: 1, 3: 1})

        {1: 0, 2: 1, 3: 1}

    """

    result = {}

    for dct in dicts:

        result.update(dct)

    return result

def requeue(queue, index=-1):

    """Returns the element at index after moving it to the beginning of the queue.

        >>> x = [1, 2, 3, 4]

        >>> requeue(x)

        4

        >>> x

        [4, 1, 2, 3]

    """

    x = queue.pop(index)

    queue.insert(0, x)

    return x

def restack(stack, index=0):

    """Returns the element at index after moving it to the top of stack.

           >>> x = [1, 2, 3, 4]

           >>> restack(x)

           1

           >>> x

           [2, 3, 4, 1]

    """

    x = stack.pop(index)

    stack.append(x)

    return x

def listget(lst, ind, default=None):

    """

    Returns `lst[ind]` if it exists, `default` otherwise.

        >>> listget(['a'], 0)

        'a'

        >>> listget(['a'], 1)

        >>> listget(['a'], 1, 'b')

        'b'

    """

    if len(lst)-1 < ind: 

        return default

    return lst[ind]

def intget(integer, default=None):

    """

    Returns `integer` as an int or `default` if it can't.

        >>> intget('3')

        3

        >>> intget('3a')

        >>> intget('3a', 0)

        0

    """

    try:

        return int(integer)

    except (TypeError, ValueError):

        return default

def datestr(then, now=None):

    """

    Converts a (UTC) datetime object to a nice string representation.

        >>> from datetime import datetime, timedelta

        >>> d = datetime(1970, 5, 1)

        >>> datestr(d, now=d)

        '0 microseconds ago'

        >>> for t, v in {

        ...   timedelta(microseconds=1): '1 microsecond ago',

        ...   timedelta(microseconds=2): '2 microseconds ago',

        ...   -timedelta(microseconds=1): '1 microsecond from now',

        ...   -timedelta(microseconds=2): '2 microseconds from now',

        ...   timedelta(microseconds=2000): '2 milliseconds ago',

        ...   timedelta(seconds=2): '2 seconds ago',

        ...   timedelta(seconds=2*60): '2 minutes ago',

        ...   timedelta(seconds=2*60*60): '2 hours ago',

        ...   timedelta(days=2): '2 days ago',

        ... }.iteritems():

        ...     assert datestr(d, now=d+t) == v

        >>> datestr(datetime(1970, 1, 1), now=d)

        'January  1'

        >>> datestr(datetime(1969, 1, 1), now=d)

        'January  1, 1969'

        >>> datestr(datetime(1970, 6, 1), now=d)

        'June  1, 1970'

        >>> datestr(None)

        ''

    """

    def agohence(n, what, divisor=None):

        if divisor: n = n // divisor

        out = str(abs(n)) + ' ' + what       # '2 day'

        if abs(n) != 1: out += 's'           # '2 days'

        out += ' '                           # '2 days '

        if n < 0:

            out += 'from now'

        else:

            out += 'ago'

        return out                           # '2 days ago'

    oneday = 24 * 60 * 60

    if not then: return ""

    if not now: now = datetime.datetime.utcnow()

    if type(now).__name__ == "DateTime":

        now = datetime.datetime.fromtimestamp(now)

    if type(then).__name__ == "DateTime":

        then = datetime.datetime.fromtimestamp(then)

    elif type(then).__name__ == "date":

        then = datetime.datetime(then.year, then.month, then.day)

    delta = now - then

    deltaseconds = int(delta.days * oneday + delta.seconds + delta.microseconds * 1e-06)

    deltadays = abs(deltaseconds) // oneday

    if deltaseconds < 0: deltadays *= -1 # fix for oddity of floor

    if deltadays:

        if abs(deltadays) < 4:

            return agohence(deltadays, 'day')

        try:

            out = then.strftime('%B %e') # e.g. 'June  3'

        except ValueError:

            # %e doesn't work on Windows.

            out = then.strftime('%B %d') # e.g. 'June 03'

        if then.year != now.year or deltadays < 0:

            out += ', %s' % then.year

        return out

    if int(deltaseconds):

        if abs(deltaseconds) > (60 * 60):

            return agohence(deltaseconds, 'hour', 60 * 60)

        elif abs(deltaseconds) > 60:

            return agohence(deltaseconds, 'minute', 60)

        else:

            return agohence(deltaseconds, 'second')

    deltamicroseconds = delta.microseconds

    if delta.days: deltamicroseconds = int(delta.microseconds - 1e6) # datetime oddity

    if abs(deltamicroseconds) > 1000:

        return agohence(deltamicroseconds, 'millisecond', 1000)

    return agohence(deltamicroseconds, 'microsecond')

def numify(string):

    """

    Removes all non-digit characters from `string`.

        >>> numify('800-555-1212')

        '8005551212'

        >>> numify('800.555.1212')

        '8005551212'

    """

    return ''.join([c for c in str(string) if c.isdigit()])

def denumify(string, pattern):

    """

    Formats `string` according to `pattern`, where the letter X gets replaced

    by characters from `string`.

        >>> denumify("8005551212", "(XXX) XXX-XXXX")

        '(800) 555-1212'

    """

    out = []

    for c in pattern:

        if c == "X":

            out.append(string[0])

            string = string[1:]

        else:

            out.append(c)

    return ''.join(out)

def commify(n):

    """

    Add commas to an integer `n`.

        >>> commify(1)

        '1'

        >>> commify(123)

        '123'

        >>> commify(1234)

        '1,234'

        >>> commify(1234567890)

        '1,234,567,890'

        >>> commify(123.0)

        '123.0'

        >>> commify(1234.5)

        '1,234.5'

        >>> commify(1234.56789)

        '1,234.56789'

        >>> commify('%.2f' % 1234.5)

        '1,234.50'

        >>> commify(None)

        >>>

    """

    if n is None: return None

    n = str(n)