def ranking(search):
try:
stores = session.query(Store).filter(Store.name.like('%' + search + '%')
).order_by(Store.average_score.desc()).all()
for index, store in enumerate(stores):
store_info = session.query(Store).filter(Store.id == store.id).first()
store_info.ranking = index + 1
session.commit()
if stores:
response = [{
"id": store.id,
"ranking": store.ranking,
"name": store.name,
"description": store.description,
"average_score": store.average_score,
"average_price": store.average_price,
"picture": os.getenv('BASE_URL') + store.picture
}for index, store in enumerate(stores)]
return response
else:
abort(400, "none data")
except SQLAlchemyError:
session.rollback()
abort(500, "database error")
def handle_other_exception(e):
if IS_DEBUG:
traceback.print_exc()
if hasattr(request, "conn"):
try:
request.conn.rollback()
except Exception:
pass
try:
session.rollback()
except Exception:
pass
data = {
"error": True,
"status": "fail",
"message": "Fail to execute lambda."
}
if IS_DEBUG:
data['debug'] = str(e)
return jsonify(data)
def register(ctx,request:YuHeLg.Request):
payload = request.json #email,pwd,name
email = payload.get("email")
#验证邮箱是否唯一
if session.query(User).filter(User.email == email).first() is not None:
raise exc.HTTPConflict("{} already exists".format(email))
user = User()
try:
user.name = payload.get("name")
user.email = payload.get("email")
user.password = bcrypt.hashpw(payload.get("password").encode(), bcrypt.gensalt())
except Exception as e:
print(e)
exc.HTTPBadRequest()
session.add(user)
try:
session.commit()
res = jsonify(user={
'id': user.id,
'name': user.name
}, token=gen_token(user.id))
print(res)
return res
except:
session.rollback()
raise exc.HTTPInternalServerError()
def cadastrar(self): #sempre chama o dicionario em funcao da funcao
self.nome = raw_input("Digite o hostname do server: ")
self.descricao = raw_input("Digite descricao para o server: ")
#self.ip = raw_input("Digite IP para o server: ")
try:
ssh = SSH()
docker = Docker()
ssh.executa_comando(docker.criar(self.nome))
container = ssh.executa_comando(docker.pegar_ip(self.nome))
container = json.loads(container)
self.ip = container[0].get("NetworkSettings").get("IPAddress")
s = ServidorModel(self)
#s.nome = servidor.get("nome")
#s.descricao = servidor.get("descricao")
#s.ip = servidor.get("ip")
session.add(s)
session.commit()
print "Servidor cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar servidor: ",e
def create_store_review(store_id, content, score, reviewer):
try:
store = session.query(Store).filter(Store.id == store_id).first()
if store:
add_review = StoreReview(store_id=store_id,
content=content,
score=score,
reviewer=reviewer,
datetime=datetime.datetime.now())
session.add(add_review)
session.commit()
average_score_calculation(store_id)
return {"message": "success for create store review"}, 201
else:
abort(400, "bad request")
except SQLAlchemyError:
session.rollback()
return abort(500, "database error")
def post_genres():
# get logged in user and user genre picks from pick_genres.html
user_obj = get_current_user()
genre_ids = [int(gi) for gi in request.form.getlist('genres')]
# modifying the collection that we're itering over is no bueno
genres_in_db = dbsession.query(Genre).all()
for g in genres_in_db:
if g in user_obj.genres:
user_obj.genres.remove(g)
try:
print "Committing..\n\n"
dbsession.commit()
except:
print "\n\n\nRolling back uh oh\n\n\n"
dbsession.rollback()
for gi in genre_ids:
genre_obj = dbsession.query(Genre).filter_by(id=gi).first()
user_obj.genres.append(genre_obj)
try:
dbsession.commit()
cache.set(session["user"].id, None, timeout=0)
except:
dbsession.rollback()
return redirect("/wall")
def pub(ctx,request:YuHeLg.Request):
payload = request.json
post = Post()
try:
post.title = payload.get("title")
post.author_id = request.user.id
post.postdate = datetime.datetime.now()
cont = Content()
cont.content = payload.get("content")
post.content = cont
tags = payload["tags"]
except Exception as e:
print(e)
raise exc.HTTPBadRequest()
taglist = re.split('[\s,]',tags)
for tag in taglist:
t = session.query(Tag).filter(Tag.tag == tag).first()
if t is None:
t = Tag()
t.tag = tag
session.add(t)
pt = Post_tag()
pt.tag = t
pt.post = post
session.add(pt)
session.add(post)
try:
session.commit()
return jsonify(post_id=post.id)
except:
session.rollback()
raise exc.HTTPInternalServerError()
def cadastrar(self): #sempre chama o dicionario em funcao da funcao
self.nome = raw_input("Digite o hostname do server: ")
self.descricao = raw_input("Digite descricao para o server: ")
#self.ip = raw_input("Digite IP para o server: ")
try:
ssh = SSH()
docker = Docker()
ssh.executa_comando(docker.criar(self.nome))
container = ssh.executa_comando(docker.pegar_ip(self.nome))
container = json.loads(container)
self.ip = container[0].get("NetworkSettings").get("IPAddress")
s = ServidorModel(self)
#s.nome = servidor.get("nome")
#s.descricao = servidor.get("descricao")
#s.ip = servidor.get("ip")
session.add(s)
session.commit()
print "Servidor cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar servidor: ", e
def get(ctx,request:YuHeLg.Request):
post_id = request.vars.id
try:
post = session.query(Post).filter(Post.id==post_id).one()
post.hits +=1
session.add(post)
try:
session.commit()
except:
session.rollback()
#处理tags
pts = session.query(Post_tag).filter(Post_tag.post_id == post_id).limit(10).all()
tags = " ".join([pt.tag.tag for pt in pts])
buryinfo, diginfo = get_digs_or_burys(post_id)
return jsonify(post={
'post_id':post.id,
'title':post.title,
'author':post.author.name,
'postdate':post.postdate.timestamp(),
'content':post.content.content,
'hits':post.hits
},diginfo=diginfo,buryinfo=buryinfo,tags=tags)
except Exception as e:
print(e)
raise exc.HTTPNotFound()
def fetch_followees(uid):
response = requests.request("GET",
followee_url_pattern.format(uid, 1),
headers=headers)
soup = BeautifulSoup(response.text, features="lxml")
try:
total_page_num = int(
soup.select("#pagelist input[name='mp']")[0]['value'])
followee_uid_list = []
for page in range(1, total_page_num + 1):
response = requests.request("GET",
followee_url_pattern.format(uid, page),
headers=headers)
soup = BeautifulSoup(response.text, features="lxml")
followees_list = soup.select("table tr td[style='width: 52px'] a")
for followee_info in followees_list:
user_url = followee_info['href']
try:
queue_info(user_url, FOLLOWEE, uid)
logging.info(
"user {}, followee of {}, has been fetched".format(
user_url, uid))
except IntegrityError:
session.rollback()
logging.info("repeat primary key {}".format(user_url))
logging.info("{}'s followee page {} finish.".format(uid, page))
time.sleep(1)
except IndexError:
logging.info("Index out of range")
def updateRecord():
name = request.form.get('name')
age = int(request.form.get('age'))
old_cno = int(request.form.get('old_cno'))
new_cno = int(request.form.get('new_cno'))
sex = request.form.get('sex')
sno = request.form.get('sno')
major = request.form.get('major')
grade = request.form.get('grade')
sd = request.form.get('sd')
province = request.form.get('province')
address = request.form.get('address')
tele = request.form.get('tele')
pnum = request.form.get('pnum')
QQ = request.form.get('QQ')
wx = request.form.get('wx')
email = request.form.get('email')
home = session.query(Home).filter(Home.cno == old_cno).first()
home.province = province
home.address = address
home.tele = tele
session.commit()
information = session.query(Information).filter(
Information.cno == old_cno).first()
information.pnum = pnum
information.QQ = QQ
information.wx = wx
information.email = email
session.commit()
school = session.query(School).filter(School.cno == old_cno).first()
school.sno = sno
school.major = major
school.grade = grade
school.sd = sd
session.commit()
person = session.query(Person).filter(Person.cno == old_cno).first()
person.cno = new_cno
person.NAME = name
person.age = age
person.sex = sex
code = 0
msg = ''
try:
session.commit()
except:
code = 100
msg = '修改失败'
session.rollback()
else:
code = 0
msg = '修改成功'
ret = {'code': code, 'msg': msg}
return jsonify(ret)
def decorated_function(*args, **kwargs):
try:
return f(*args, **kwargs)
except:
print "Error: ", sys.exc_info()[0]
dbsession.rollback()
raise ValueError("An error occurred")
finally:
dbsession.close()
def remover_usuario():
listar_usuario()
indice = input("Digite o id do usuario: ")
try:
usuario = session.query(UsuarioModel).filter_by(id=indice).first()
session.delete(usuario)
session.commit()
except Exception as e:
session.rollback()
print "Falhou ao remover usuario: ",e
def handle_dcca_exception(e):
try:
request.conn.rollback()
except Exception:
pass
try:
session.rollback()
except Exception:
pass
return jsonify({"error": True, "status": "fail", "message": str(e)})
def get_data():
#if request.method == "POST":
rdict = {"aname": '', "img_hash": '', "title": ''}
for item in rdict:
rdict[item] = request.values.get(item, '')
row_update_dict = {}
row2_update_dict = {}
if rdict["aname"] == u"不保留":
row_update_dict['valid'] = 0
row_update_dict['label'] = 1
elif rdict["aname"] == u"上一张":
session = DBSession()
session.expire_on_commit = False
session.query(PicLabel).filter(
PicLabel.image_hash == rdict["img_hash"]).update(
{PicLabel.current: 0})
uquerys = session.query(PicLabel).filter(
PicLabel.title == rdict["title"]).filter(
or_(PicLabel.label == 0,
PicLabel.image_hash == rdict["img_hash"])).order_by(
PicLabel.episode, PicLabel.frame_timestamp).all()
for idx, uquery in enumerate(uquerys):
if uquery.image_hash == rdict["img_hash"]:
index = idx
length = len(uquerys)
uquery = uquerys[(length + index - 2) % length]
session.query(PicLabel).filter(
PicLabel.image_hash == uquery.image_hash).update(
{PicLabel.current: 1})
session.commit()
session.close()
elif rdict["aname"] != u"跳过" and rdict["aname"] != u"上一张":
row_update_dict['aname'] = rdict['aname']
row_update_dict['label'] = 1
# row2_update_dict['status'] = 1
session = DBSession()
try:
if row_update_dict:
session.query(PicLabel).filter_by(
image_hash=rdict["img_hash"]).update(row_update_dict)
if row2_update_dict:
session.query(CheckActor).filter(
CheckActor.actor == rdict["aname"]).update(row2_update_dict)
session.commit()
except:
session.rollback()
finally:
session.close()
#url, img_hash, title, episode, frame_timestamp = get_url(rdict["title"])
#return jsonify(url=url, img_hash=img_hash, title=title, episode=episode, frame_timestamp=frame_timestamp)
return jsonify({'error_code': 0})
def cadastrar(self):
self.login = raw_input("Digite o login do usuario: ")
self.senha = raw_input("Digite a senha:")
try:
u = UsuarioModel(self)
session.add(u)
session.commit()
print "Usuario cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar usuario: ", e
def cadastrar(self):
self.login = raw_input("Digite o login do usuario: ")
self.senha = raw_input("Digite a senha:")
try:
u = UsuarioModel(self)
session.add(u)
session.commit()
print "Usuario cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar usuario: ",e
def insert_data(name, cno, age, sex, sno, major, grade, sd, province, address,
tele, pnum, QQ, wx, email):
try:
session.execute(
f"call insert_data('{name}', {cno}, {age}, '{sex}', '{sno}', '{major}', '{grade}', '{sd}', '{province}', '{address}', '{tele}', '{pnum}', '{QQ}', '{wx}', '{email}');"
)
except:
session.rollback()
return (100, '插入失败，记录已存在')
else:
return (0, '插入成功')
def cadastrar_servidor():
servidor = {}
servidor["hostname"] = raw_input("Digite o nome do servidor:")
servidor["descricao"] = raw_input("Digite uma descricao: ")
try:
s = ServidorModel()
s.nome = servidor.get("hostname")
s.descricao = servidor.get("descricao")
session.add(s)
session.commit()
except Exception as e:
session.rollback()
print "Falhou ao cadastrar servidor: ", e
def remover_servidor():
listar_servidor()
servidor_id = input("Digite o id do servidor: ")
try:
servidor = session.query(ServidorModel) \
.filter_by(id=servidor_id).first()
session.delete(servidor)
session.commit()
print "Servidor removido com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao remover servidor: ", e
def dig_or_bury(user_id,post_id,value=1):
dig = Dig()
dig.user_id = user_id
dig.post_id = post_id
dig.state = value
dig.pubdate = datetime.datetime.now()
session.add(dig)
try:
session.commit()
return jsonify()
except:
session.rollback()
return jsonify(500)
def cadastrar_servidor():
servidor = {}
servidor["hostname"] = raw_input("Digite o nome do servidor:")
servidor["descricao"] = raw_input("Digite uma descricao: ")
try:
s = ServidorModel()
s.nome = servidor.get("hostname")
s.descricao = servidor.get("descricao")
session.add(s)
session.commit()
except Exception as e:
session.rollback()
print "Falhou ao cadastrar servidor: ",e
def remover_servidor():
listar_servidor()
servidor_id = input("Digite o id do servidor: ")
try:
servidor = session.query(ServidorModel) \
.filter_by(id=servidor_id).first()
session.delete(servidor)
session.commit()
print "Servidor removido com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao remover servidor: ",e
def cadastrar_usuario():
usuario = {}
usuario['login'] = raw_input("Digite o login do usuario: ")
usuario['senha'] = raw_input("Digite a senha:")
try:
u = UsuarioModel()
u.nome = usuario.get("login")
u.senha = usuario.get("senha")
session.add(u)
session.commit()
print "Usuario cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar usuario: ",e
def cadastrar(self):
self.login = raw_input("Digite o login do usuario: ")
self.senha = raw_input("Digite sua senha: ")
try:
u = UsuarioModel(self)
#u.nome=self.login #recebido pelo contrutor do model.usuario
#u.senha = self.senha
session.add(u)
session.commit()
print "Usuario cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar usuario: ", e
def cadastrar(self):
self.login = raw_input("Digite o login do usuario: ")
self.senha = raw_input("Digite sua senha: ")
try:
u = UsuarioModel(self)
#u.nome=self.login #recebido pelo contrutor do model.usuario
#u.senha = self.senha
session.add(u)
session.commit()
print "Usuario cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar usuario: ",e
def get_percent(table_name, field_name):
sql = f"SELECT `{field_name}`,number,concat( round( number / total * 100.00, 2 ), '%' ) percent FROM( SELECT * FROM (SELECT `{field_name}`,COUNT( 1 ) number FROM `{table_name}` GROUP BY `{field_name}` ) t1 INNER JOIN ( SELECT COUNT( 1 ) total FROM `{table_name}` ) t2 ON 1 = 1 ) t;"
try:
result = session.execute(sql)
except:
session.rollback()
percentList = result.fetchall() # [('计算机',5,'8.00%'), ...]
ret = []
for percent in percentList:
data = {
'name': percent[0],
'value': percent[1],
}
ret.append(data)
return ret
def enrollment_store_product(store_id, product_name, picture_url):
try:
add_product = Product(store_id=store_id,
name=product_name,
picture=picture_url)
session.add(add_product)
session.commit()
return {"message": "success for create store product"}
except SQLAlchemyError:
session.rollback()
return abort(500, "database_error")
def cadastrar_usuario(): #sempre chama o dicionario em funcao da funcao
usuario = {} #dicionario recebe user e pass. vazio mesmo
usuario ['login'] = raw_input("Digite o login do usuario: ")
usuario ['senha'] = raw_input("Digite sua senha: ")
try:
u = UsuarioModel()
u.nome = usuario.get("login")
u.senha = usuario.get("senha")
session.add(u)
session.commit()
print "Usuario cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar usuario: ",e
def cadastrar_usuario(): #sempre chama o dicionario em funcao da funcao
usuario = {} #dicionario recebe user e pass. vazio mesmo
usuario['login'] = raw_input("Digite o login do usuario: ")
usuario['senha'] = raw_input("Digite sua senha: ")
try:
u = UsuarioModel()
u.nome = usuario.get("login")
u.senha = usuario.get("senha")
session.add(u)
session.commit()
print "Usuario cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar usuario: ", e
def cadastrar(self):
self.nome = raw_input("Digite o nome do servidor:")
self.descricao = raw_input("Digite uma descricao: ")
try:
# instancia dos objetos Docker
docker = Docker()
docker.criar(self.nome)
container = docker.pegar_ip(self.nome)
container = json.loads(container)
self.ip = container[0].get("NetworkSettings").get("IPAddress")
s = ServidorModel(self)
session.add(s)
session.commit()
except Exception as e:
session.rollback()
print "Falhou ao cadastrar servidor: ", e
def cadastrar(self):
self.nome = raw_input("Digite o nome do servidor:")
self.descricao = raw_input("Digite uma descricao: ")
try:
# instancia dos objetos Docker
docker = Docker()
docker.criar(self.nome)
container = docker.pegar_ip(self.nome)
container = json.loads(container)
self.ip = container[0].get("NetworkSettings").get("IPAddress")
s = ServidorModel(self)
session.add(s)
session.commit()
except Exception as e:
session.rollback()
print "Falhou ao cadastrar servidor: ",e
def cadastrar_servidor(): #sempre chama o dicionario em funcao da funcao
servidor = {} #dicionario recebe servidores/desc. vazio mesmo
servidor ["nome"] = raw_input("Digite o hostname do server: ")
servidor ["descricao"] = raw_input("Digite descricao para o server: ")
servidor ["ip"] = raw_input("Digite IP para o server: ")
try:
s = ServidorModel()
s.nome = servidor.get("nome")
s.descricao = servidor.get("descricao")
s.ip = servidor.get("ip")
session.add(s)
session.commit()
print "Servidor cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar servidor: ",e
def cadastrar_servidor(): #sempre chama o dicionario em funcao da funcao
servidor = {} #dicionario recebe servidores/desc. vazio mesmo
servidor["nome"] = raw_input("Digite o hostname do server: ")
servidor["descricao"] = raw_input("Digite descricao para o server: ")
servidor["ip"] = raw_input("Digite IP para o server: ")
try:
s = ServidorModel()
s.nome = servidor.get("nome")
s.descricao = servidor.get("descricao")
s.ip = servidor.get("ip")
session.add(s)
session.commit()
print "Servidor cadastrado com sucesso!"
except Exception as e:
session.rollback()
print "Falhou ao cadastrar servidor: ", e
def create_product_review(product_id, content, score, reviewer):
try:
add_review = ProductReview(product_id=product_id,
content=content,
score=score,
reviewer=reviewer,
datetime=datetime.datetime.now())
session.add(add_review)
session.commit()
return {"message": "success for created product review"}, 201
except SQLAlchemyError:
session.rollback()
return abort(500, "database error")
def enrollment_store(store_name, description, score, average_price,
picture_url):
try:
add_store = Store(name=store_name,
description=description,
average_price=average_price,
picture=picture_url,
average_score=score)
session.add(add_store)
session.commit()
return {"message": "success for create store information"}
except SQLAlchemyError:
session.rollback()
return abort(500, "database_error")
def fetch_followers(uid):
response = requests.request("GET",
follower_url_pattern.format(uid, 1),
headers=headers)
soup = BeautifulSoup(response.text, features="lxml")
try:
total_page_num = int(
soup.select("#pagelist input[name='mp']")[0]['value'])
fan_uid_list = []
for page in range(1, total_page_num + 1):
refresh_count = 0
fan_list = []
while len(fan_list) == 0 and refresh_count < 4:
time.sleep(1)
logging.info(
"{}'s follower page {} begin. refresh count {}".format(
uid, page, refresh_count))
response = requests.request("GET",
follower_url_pattern.format(
uid, page),
headers=headers)
soup = BeautifulSoup(response.text, features="lxml")
refresh_count += 1
fans_list = soup.select("table tr td[style='width: 52px'] a")
if len(fan_list) == 0:
logging.info("{}'s follower page {} is empty. break".format(
uid, page))
break
for fan_info in fans_list:
# uid_arr = chat_re_pattern.findall(fan_info['href'])
user_url = fan_info['href']
try:
queue_info(user_url, FOLLOWER, uid)
logging.info(
"user {}, follower of {}, has been fetched".format(
user_url, uid))
session.commit()
except IntegrityError:
session.rollback()
logging.info("repeat primary key {}".format(user_url))
logging.info("{}'s follower page {} finish.".format(uid, page))
except IndexError:
logging.info("Index out of range")
def fetch_profile(user_url):
response = requests.request("GET", user_url, headers=headers)
soup = BeautifulSoup(response.text, features="lxml")
try:
info_str = soup.select(
"div[class='u'] table td span[class='ctt']")[0].get_text()
name, location = profile_re_pattern.findall(info_str)[0]
logging.info("name: {}, location: {}".format(name, location))
try:
user = User(uid, name, location)
ele = FollowQueue(uid)
session.add(user)
session.add(ele)
session.query(InfoQueue).filter(InfoQueue.uid == uid).delete()
logging.info("info dequeued {}".format(uid))
session.commit()
except IntegrityError:
session.rollback()
logging.info("repeat primary key")
except IndexError:
logging.info("Index out of range")
def fetch_info(user_url):
uid = None
response = requests.request("GET", user_url, headers=headers)
soup = BeautifulSoup(response.text, features="lxml")
try:
info_str = soup.select(
"div[class='u'] table td span[class='ctt']")[0].get_text()
uid = avatar_re_pattern.findall(
soup.select("div[class='u'] table td a")[0]['href'])[0]
name, location = profile_re_pattern.findall(info_str)[0]
logging.info("uid: {}, name: {}, location: {}".format(
uid, name, location))
try:
user = User(uid, name, location)
queue_follow(uid)
# ele = FollowQueue(uid)
session.add(user)
# session.add(ele)
session.commit()
except IntegrityError:
session.rollback()
logging.info("repeat primary key")
except IndexError:
logging.error("Index out of range")
t = 0
with open('log/info_consumer/index_error_times.log', 'r') as f:
t = int(f.read()) + 1
if t > 4:
first_info_obj = session.query(InfoQueue).order_by(
InfoQueue.create_time).first()
session.delete(first_info_obj)
session.commit()
logging.info(
'remove first obj in info queue since there is some problems'
)
with open('log/info_consumer/index_error_times.log', 'w') as f:
f.write(str(t))
exit(-1)
return uid
def dequeue_info():
first_info_obj = session.query(InfoQueue).order_by(
InfoQueue.create_time).first()
if first_info_obj != None:
# uid = first_info_obj.uid
user_url = first_info_obj.url
logging.info("got first url in info queue {}".format(user_url))
uid = fetch_info(user_url)
logging.info("got info of {}".format(uid))
relations_in_buffer = session.query(InfoQueue).filter(InfoQueue.url==user_url)\
.all()
for relation in relations_in_buffer:
relation_obj = None
if relation.follow_or_fan == FOLLOWEE:
relation_obj = UserRelationship(uid, relation.source_uid)
logging.info("build relationship between {} and {}".format(
uid, relation.source_uid))
elif relation.follow_or_fan == FOLLOWER:
relation_obj = UserRelationship(relation.source_uid, uid)
logging.info("build relationship between {} and {}".format(
relation.source_uid, uid))
try:
session.add(relation_obj)
session.delete(relation)
logging.info("dequeue relationship between {} and {}".format(
relation.source_uid, uid))
session.commit()
except IntegrityError:
session.rollback()
logging.info("repeat primary key")
session.delete(relation)
logging.info(
"re-dequeue relationship between {} and {}".format(
relation.source_uid, uid))
session.commit()
with open('log/info_consumer/index_error_times.log', 'w') as f:
f.write('0')
if count == 0:
continue
start = 0
while start < count:
song_list = baidu.get_song_list(artist, start)
if not song_list or len(song_list) == 0:
break
for song in song_list:
down_url, artist_name, song_name = baidu.get_download_url(song)
try:
lrc_url = 'http://music.baidu.com' + baidu.get_lrc_url(song)
except:
lrc_url = ''
if not down_url or not down_url.startswith('http://yinyueshiting.baidu.com'):
continue
down.write('{}\n{}\n'.format(down_url, lrc_url))
try:
record.write('{}\t{}\t{}\t{}\n'.format(song_name, artist_name, down_url, lrc_url))
b = Baidu(name=song_name.decode('utf8'), singer=artist_name.decode('utf8'), url=down_url, lrc=lrc_url)
session.add(b)
except Exception as e:
continue
start += 25
try:
session.commit()
except SQLAlchemyError as e:
session.rollback()
sql_err.write('{}\t{}\n'.format(artist, e))
