+
−import dircache, os.path
+
−from sys import stderr
+
−import readline
+
−
+
−def sql_quote(str):
+
−    return str.replace("'", "''")
+
−
+
−def get_song_info(path):
+
−    "Return (artist, title) pair from path."
+
−    artist, title = None, None
+
−    if os.path.isfile(path):
+
−        if path[-4:] == '.mp3':
+
−            from ID3 import ID3
+
−            id3 = ID3(path)
+
−            try:
+
−                artist = id3['ARTIST']
+
−            except:
+
−                pass
+
−            try:
+
−                title = id3['TITLE']
+
−            except:
+
−                pass
+
−        elif path[-4:] == '.ogg':
+
−            from ogg.vorbis import VorbisFile
+
−            vf = VorbisFile(path)
+
−            vc = vf.comment()
+
−            try:
+
−                artist = vc['ARTIST'][0]
+
−            except:
+
−                pass
+
−            try:
+
−                title = vc['TITLE'][0]
+
−            except:
+
−                pass
+
−    return artist, title
+
−
+
−def strdelay(seconds):
+
−    secs = abs(round(seconds))
+
−    minutes = secs / 60;
+
−    hours = minutes / 60;
+
−    days = hours / 24;
+
−    secs = secs % 60;
+
−    minutes %= 60;
+
−    hours %= 24;
+
−
+
−    if seconds < 0:
+
−            s = "-"
+
−    else:
+
−            s = ""
+
−    if days >= 1:
+
−            s += "%dd %dh" % (days, hours)
+
−    elif hours >= 1:
+
−            s += "%dh%02d" % (hours, minutes)
+
−    elif minutes >= 1:
+
−            s += "%d'%02d\"" % (minutes, secs)
+
−    else:
+
−            s += "%d\"" % (secs)
+
−    return s
+
−
+
−def set_file_completer():
+
−    readline.set_completer_delims('')
+
−    readline.set_completer(_file_completer)
+
−
+
−def _file_completer(text, state):
+
−    dirname, filename = os.path.split(text)
+
−    if not os.path.isdir(dirname):
+
−        return None
+
−    paths = dircache.listdir(dirname)
+
−    tlen = len(filename)
+
−    checkpaths = []
+
−    if tlen > 0:
+
−        for fn in paths:
+
−            if fn[:len(filename)] == filename:
+
−                checkpaths.append(fn)
+
−    else:
+
−        checkpaths = paths
+
−    if len(checkpaths) > state:
+
−        return os.path.join(dirname, checkpaths[state])
+
−    return None
+
−    
+
−def copy_file(origname, copyname):
+
−    orig = file(origname, 'r')
+
−    new = file(copyname, 'w')
+
−    new.write(orig.read())
+
−    new.flush()
+
−    return new
+
−
+
−def unique(s):
+
−    """Return a list of the elements in s, but without duplicates.
+
−
+
−    For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
+
−    unique("abcabc") some permutation of ["a", "b", "c"], and
+
−    unique(([1, 2], [2, 3], [1, 2])) some permutation of
+
−    [[2, 3], [1, 2]].
+
−
+
−    For best speed, all sequence elements should be hashable.  Then
+
−    unique() will usually work in linear time.
+
−
+
−    If not possible, the sequence elements should enjoy a total
+
−    ordering, and if list(s).sort() doesn't raise TypeError it's
+
−    assumed that they do enjoy a total ordering.  Then unique() will
+
−    usually work in O(N*log2(N)) time.
+
−
+
−    If that's not possible either, the sequence elements must support
+
−    equality-testing.  Then unique() will usually work in quadratic
+
−    time.
+
−    """
+
−
+
−    n = len(s)
+
−    if n == 0:
+
−        return []
+
−
+
−    # Try using a dict first, as that's the fastest and will usually
+
−    # work.  If it doesn't work, it will usually fail quickly, so it
+
−    # usually doesn't cost much to *try* it.  It requires that all the
+
−    # sequence elements be hashable, and support equality comparison.
+
−    u = {}
+
−    try:
+
−        for x in s:
+
−            u[x] = 1
+
−    except TypeError:
+
−        del u  # move on to the next method
+
−    else:
+
−        return u.keys()
+
−
+
−    # We can't hash all the elements.  Second fastest is to sort,
+
−    # which brings the equal elements together; then duplicates are
+
−    # easy to weed out in a single pass.
+
−    # NOTE:  Python's list.sort() was designed to be efficient in the
+
−    # presence of many duplicate elements.  This isn't true of all
+
−    # sort functions in all languages or libraries, so this approach
+
−    # is more effective in Python than it may be elsewhere.
+
−    try:
+
−        t = list(s)
+
−        t.sort()
+
−    except TypeError:
+
−        del t  # move on to the next method
+
−    else:
+
−        assert n > 0
+
−        last = t[0]
+
−        lasti = i = 1
+
−        while i < n:
+
−            if t[i] != last:
+
−                t[lasti] = last = t[i]
+
−                lasti += 1
+
−            i += 1
+
−        return t[:lasti]
+
−
+
−    # Brute force is all that's left.
+
−    u = []
+
−    for x in s:
+
−        if x not in u:
+
−            u.append(x)
+
−    return u
+
−
+
−