113 lines
2.3 KiB
Python
113 lines
2.3 KiB
Python
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
|
|
|