def word_won(word):
try:
query = Word.update(wins=Word.wins + 1).where(Word.text == word)
query.execute()
except:
db.rollback()
raise
def session_clear(exception=None):
"""
Resolve database session issues for the combination of Postgres/Sqlalchemy to rollback database transactions after an exception is thrown.
"""
db.remove()
if exception and db.is_active:
db.rollback()
def _handle_request_exception(self, e):
db.rollback()
if isinstance(e, JsonException):
print(e.to_json())
self.finish_json(errcode=e.errcode, errmsg=e.errmsg)
else:
super(BaseHandler, self)._handle_request_exception(e)
def word_won(word):
try:
query = Word.update(wins=Word.wins + 1).where(Word.text == word)
query.execute()
except:
db.rollback()
raise
def save_stock(stock):
try:
stock.save(force_insert=True)
logger.info(f'Stock object: {stock.code} of {stock.name} saved in db')
except Exception as exception:
logger.error(f'{stock.code} is allready exist: {exception}')
db.rollback()
def save_trades(element_list, stock_code, insider_code):
for element in element_list:
trade = Trade()
trade.stock = stock_code
trade.insider = insider_code
trade.relation = element[2]
trade_last_date = datetime.date(
datetime.strptime(element[3], '%m/%d/%Y'))
trade.last_date = trade_last_date
trade.transaction_type = element[4]
trade.owner_type = element[5]
shares_traded = element[6].replace(',', '')
if shares_traded == '':
shares_traded = 0
trade.shares_traded = shares_traded
last_price = element[7]
if last_price == '':
last_price = 0.0
trade.last_price = last_price
shares_held = element[8].replace(',', '')
if shares_held == '':
shares_held = 0
trade.shares_held = shares_held
try:
trade.save()
logger.info(
f'Trade object of {stock_code} on last date {element[2]} saved in db'
)
except Exception as exception:
logger.error(f'{stock_code} is allready exist: {exception}')
db.rollback()
def create_venue_submission():
form_data = VenueForm()
genres = ",".join(form_data.getlist("genres"))
new_venue = Venue(
name=form_data.name.data,
city=form_data.city.data,
state=form_data.state.data,
address=form_data.address.data,
phone=form_data.phone.data,
image_link=form_data.image_link.data,
facebook_link=form_data.facebook_link.data,
genres=genres,
website=form_data.website_link.data,
seeking_talent=form_data.seeking_talent.data,
seeking_description=form_data.seeking_description.data,
)
try:
db.session.add(new_venue)
except Exception as e:
db.rollback()
flash("An error occurred. Venue " + form_data.name.data +
" could not be listed.")
else:
db.session.commit()
flash('Venue ' + new_venue.name + ' was successfully listed!')
finally:
db.session.close()
return render_template('pages/home.html')
def post(self):
"""
headers = Token
args = {"title": title, "text": text, "tags": tag1,tag2,tag3,...}
"""
user = auth_token()
if not user:
return response_model(), 401
req = get_json_data("title", "text", "tags")
if not req:
return response_model(), 400
# author -> this is user from authentication
# add Post object
with db.transaction():
try:
p = Post(author=user, title=req['title'].encode('utf-8'), text=req['text'].encode('utf-8'))
p.save()
for tag in req['tags'].split(","):
tmp, _ = Tag.get_or_create(name=tag)
apat = AssociationPostAndTag(post=p, tag=tmp)
apat.save()
except:
db.rollback()
return response_model(), 400
return response_model(), 200
def sign_up():
if request.method == 'POST':
name = request.form['name']
email = request.form['email']
contact_number = request.form['contact_number']
password = request.form['password']
gender = request.form['gender']
created_at = datetime.datetime.now()
password_hash = encrpyt.hash(password)
if gender == "male":
gender = "M"
else:
gender = "F"
usr = User(name = name,email= email,contact_number= contact_number,password= password_hash,
gender= gender,created_at= created_at)
try:
db.session.add(usr)
db.session.commit()
flash("User added successfully!!","Success")
except:
db.rollback()
flash("Please try again","error")
return redirect(url_for("home"))
return render_template("sign_up.html")
def save_individual_trades(element_list, individual_code):
for element in element_list:
insider_trade = IndividualInsiderTrades()
link = element[0]
stock_code = link.replace('https://www.nasdaq.com/symbol/', '')
stock_code = stock_code.replace('/insider-trades',
'').strip(' \t\n\r').upper()
print(stock_code)
try:
Stock().get_by_id(stock_code)
print('success')
insider_trade.company = stock_code
except Exception:
stock = Stock()
stock_url = make_url('main', stock_code)
stock_page = load_page(stock_url)
stock_name = scrape_stock_name(stock_page)
stock.name = stock_name
stock.code = stock_code
save_stock(stock)
insider_trade.company = Stock().get_by_id(stock_code)
insider_trade.insider = individual_code
insider_trade.relation = element[2]
trade_last_date = datetime.date(
datetime.strptime(element[3], '%m/%d/%Y'))
insider_trade.last_date = trade_last_date
insider_trade.tran = element[5]
insider_trade.owner_type = element[6]
shares_traded = element[7].replace(',', '')
if shares_traded == '':
shares_traded = 0
insider_trade.shares_traded = shares_traded
last_price = element[8]
if last_price == '':
last_price = 0.0
insider_trade.last_price = last_price
shares_held = element[9].replace(',', '')
if shares_held == '':
shares_held = 0
insider_trade.shares_held = shares_held
try:
insider_trade.save()
logger.info(
f'Trade object of {individual_code} on last date {element[3]} saved in db'
)
except Exception as exception:
print(exception)
logger.error(f'{individual_code} is allready exist: {exception}')
db.rollback()
def save_insider(element_list):
for element in element_list:
insider = Insider()
insider.code = element[0]
insider.name = element[1]
try:
insider.save(force_insert=True)
logger.info(
f'Insider object of {element_list[0]} --- {element[1]} saved in db'
)
return insider
except Exception as exception:
logger.error(f'{element_list[0]} is allready exist: {exception}')
db.rollback()
return insider
def feedback(user_id,name):
if request.method == "POST":
rating = request.form["rating"]
comments = request.form["comment"]
feed = Feedback(user_id,comments,rating)
try:
db.session.add(feed)
db.session.commit()
flash("Feedback saved successfully","Success")
except:
db.rollback()
flash("Please try again","error")
return redirect(url_for("dashboard",user_id = user_id,name=name))
return render_template("feedback.html",name=name,user_id=user_id)
def upload_all_groups(self, ):
"""
upload AffinityPropagation model for to define a users' group and updating all users
:return None:
"""
dataset = []
users = []
count = Users.select().count()
for i in range(0, count, 100):
usrs = Users.select().offset(i).limit(100).execute()
for u in usrs:
users.append(model_to_dict(u))
for u in users:
dataset.append(self.user_preparation(u))
from sklearn.cluster import AffinityPropagation
clustering = AffinityPropagation(affinity='euclidean',
convergence_iter=15,
copy=True,
damping=0.5,
max_iter=200,
preference=None,
verbose=False).fit(dataset)
all_users = Users.select().execute()
for u in all_users:
u.group = self.get_group(u)
with db.atomic() as txn:
try:
Users.bulk_update(all_users, fields=[Users.group])
except peewee.Error as e:
logger.error(str(e))
db.rollback()
@test
def unsave():
txn.rollback()
@not_test
def save():
import pickle
pickle.dump(clustering, open(PATH_TO_DIR + "clustering", "wb"))
def get_next_word(used=None):
try:
# Fetch a random word that hasn't been used much
subquery = Word.select(fn.Avg(Word.plays))
result = (Word.select().order_by(
fn.Random()).where(Word.plays <= subquery))
if used:
result = result.where((Word.text << used) == False)
result = result[0]
# Update its play count
query = Word.update(plays=Word.plays + 1).where(Word.id == result.id)
query.execute()
return result
except:
db.rollback()
raise
def get_next_word(used=None):
try:
# Fetch a random word that hasn't been used much
subquery = Word.select(fn.Avg(Word.plays))
result = (Word.select()
.order_by(fn.Random())
.where(Word.plays <= subquery))
if used:
result = result.where((Word.text << used) == False)
result = result[0]
# Update its play count
query = Word.update(plays=Word.plays + 1).where(Word.id == result.id)
query.execute()
return result
except:
db.rollback()
raise
def create_artist_submission():
# called upon submitting the new artist listing form
form_data = ArtistForm()
genres = ",".join(form_data.genres.data)
new_artist = Artist(
name=form_data.name.data,
city=form_data.city.data,
state=form_data.state.data,
phone=form_data.phone.data,
image_link=form_data.image_link.data,
facebook_link=form_data.facebook_link.data,
genres=genres,
website=form_data.website_link.data,
seeking_venue=form_data.seeking_venue.data,
seeking_description=form_data.seeking_description.data,
)
try:
db.session.add(new_artist)
db.session.flush()
availabilities = [
ArtistAvailability(artist_id=new_artist.id,
time_from=d.get('time_from'),
day=d.get('day'),
time_to=d.get('time_to'))
for d in form_data.availabilities.data
if d.get('day') and d.get('time_from') and d.get('time_to')
]
db.session.add_all(availabilities)
except Exception as e:
db.rollback()
flash("An error occurred. Artist " + form_data.name.data +
" could not be listed.")
else:
db.session.commit()
flash('Artist ' + new_artist.name + ' was successfully listed!')
finally:
db.session.close()
return render_template('pages/home.html')
def delete_branch(branch_id):
#suppose succes is false
success = False
branch = Branches.query.get(branch_id)
try:
db.session.delete(branch)
db.session.commit()
success = True
except:
db.rollback()
success = False
finally:
db.session.close()
if (success):
flash('Branch \"' + branch.name + '\" deleted successfully!',
'success')
return redirect(url_for('branches'))
else:
flash('Branch \"' + branch.name + '\" could not be deleted!',
'danger')
return render_template('pages/branches/delete.html', branch=branch)
def cadastro():
erros = campos_presentes_na_requisicao('nome email senha tipo_usuario')
if erros:
return render_template('usuario/cadastro.html', erros=erros), 400
nome = request.form.get('nome')
email = request.form.get('email')
senha = request.form.get('senha')
tipo_usuario = int(request.form.get('tipo_usuario'))
# Cadastrar usuário
with db.atomic() as transacao:
novo_usuario = Usuario.create(nome=nome,
email=email,
tipo_usuario=tipo_usuario,
hash_senha=senha_hasheada(senha))
# Criar professor ou aluno, dependendo do tipo_usuario
try:
resposta, codigo = cadastrar[TipoUsuario(tipo_usuario)](
novo_usuario)
if codigo != 200:
db.rollback()
flash(resposta)
session['usuario'] = model_to_dict(novo_usuario)
return redirect(url_for('pagina_inicial'))
except Exception as e:
db.rollback()
print(e)
flash(
'Algo de errado aconteceu ao cadastrar o usuário. Por favor, tente mais tarde.'
)
return render_template('usuario/cadastro.html'), 500
def tearDownModule(self):
db.rollback()
db.close()
os.environ.pop("TEST")
def rollback_on_database_error(error):
db.rollback()
raise error
import datetime
import populate
from models import db
populate.create_tables()
print(f'Script started at: {datetime.datetime.now()}')
with db.atomic() as transaction:
try:
populate.congress()
populate.paper()
populate.update_paper()
except Exception as e:
db.rollback()
print('Error: ', e)
print(f'Script finished at: {datetime.datetime.now()}')