db_encoding = 'utf8'

def value_to_db(value):
    if type(value) == unicode:
        return value.encode(db_encoding)
    return value

def value_from_db(value):
    if type(value) == str:
        return unicode(value, db_encoding)
    return value

def execute_query(cursor, query, bindings):
    for (key, val) in bindings.items():
        if val == None:
            query = query.replace('%(' + key + ')d', 'NULL')
    bindings = map_dict(value_to_db, bindings)
    cursor.execute(query, bindings)

def fetchone(cursor):
    a = cursor.fetchone()
    if a != None:
        return map(value_from_db, a)
    return None

def fetchall(cursor):
    return map(lambda row: map(value_from_db, row),
               cursor.fetchall())

def make_result_dict(cursor, row):
    d = {}
    for i in xrange(len(row)):
        d[cursor.description[i][0]] = row[i]
    return d

def fetchone_dict(cursor):
    row = fetchone(cursor)
    if row != None:
        return make_result_dict(cursor, row)
    return None

def fetchall_dict(cursor):
    return map(lambda r: make_result_dict(cursor, r),
               fetchall(cursor))

def first(lst):
    return lst[0]

def second(lst):
    return lst[1]

def count(predicate, lst):
    c = 0
    for elem in lst:
        if predicate(elem):
            c = c+1
    return c

def find(predicate, lst):
    for elem in lst:
        if predicate(elem):
            return elem
    return None

def unique(lst):
    newlst = []
    for elem in lst:
        if elem not in newlst:
            newlst.append(elem)
    return newlst

def mapcond(fun, predicate, lst):
    def mapfun(x):
        if predicate(x):
            return fun(x)
        return x
    return map(mapfun, lst)

def map_dict(fun, d):
    res = {}
    for key in d:
        res[key] = fun(d[key])
    return res

def maptup(fun, lst):
    return tuple(map(fun, lst))

def translate(value, translations):
    return translations.get(value, value)

def str_or_empty(value):
    if value:
        return str(value)
    return ''

def p(s):
    encoded = s
    if isinstance(s, unicode):
        encoded = s.encode('utf8')
    print encoded

def cut_str(string, length, ellipsis='...'):
    if len(string) < length:
        return string
    return string[0:length-len(ellipsis)]+ellipsis

def combine_dicts(*dicts):
    res = {}
    for d in dicts:
        res.update(d)
    return res