def sign_up():
form = SignUpForm()
user = User()
if form.validate_on_submit():
user_name = request.form.get('user_name')
user_email = request.form.get('user_email')
register_check = User.login_check(user_name)
if register_check:
flash("error: The user's name already exists!")
return redirect('/sign-up')
if len(user_name) and len(user_email):
user.nickname = user_name
user.email = user_email
try:
session = Session()
session.add(user)
session.commit()
except:
flash("The Database error!")
return redirect('/sign-up')
flash("Sign up successful!")
return redirect('/index')
return render_template(
"sign_up.html",
form=form)
def main():
from_date = datetime.date(*map(int, sys.argv[1].split('-')))
to_date = datetime.date(*map(int, sys.argv[2].split('-')))
assert from_date <= to_date
quote = decode_quote(sys.argv[3])
#print quote
session = Session()
lit_years = {}
date = from_date
while date <= to_date:
found = False
session.rollback()
lit_date = get_lit_date(date, lit_years, session)
masses = []
try:
masses = lit_date.get_masses(strict=True)
except SelectingMassException:
pass
for mass in masses:
if found:
break
for reading in mass.readings:
try:
verses = decode_quote(reading.quote)
except BadQuoteException:
pass
if quotes_intersect(quote, verses):
print "%s: %s" % (date, reading.quote)
found = True
break
date += datetime.timedelta(days=1)
def register_view(self):
form = RegistrationForm(request.form)
if request.method == 'POST' and form.validate():
user = Users()
user.username = form.username.data
user.email = form.email.data
user.roles = ','.join(form.role.data)
# we hash the users password to avoid saving it as plaintext in the db,
# remove to use plain text:
user.password = generate_password_hash(form.password.data)
Session.add(user)
Session.commit()
login.login_user(user)
flash('Thanks for registering')
return redirect(url_for('.index'))
link = '<p>Already have an account? <a href="' + url_for('.login_view') + '">Click here to log in.</a></p>'
form_roles = []
roles = Session.query(Role).all()
for role in roles:
form_roles.append((role.key, role.name))
form.role.choices = form_roles
self._template_args['form'] = form
self._template_args['link'] = link
return super(MyAdminIndexView, self).index()
def get_announcements(course, url):
'''Gets all new announcements
Returns a list of all new announcements.
'''
session = Session()
try:
r = s.get('https://edux.pjwstk.edu.pl/Announcements.aspx', stream=True)
r.raise_for_status()
new_announcements = extract_announcements(r.content)
# All pairs of (timestamp, message) are saved to db
# if they arent there already
for (timestamp, message) in new_announcements:
announcement = session.query(Announcement). \
filter_by(course=course,
created_at=timestamp,
message=message). \
first()
if announcement is None:
# This is what we care about
announcement = Announcement(
course=course,
created_at=timestamp,
message=message)
session.add(announcement)
print u'New announcement at {0}'.format(timestamp)
yield (timestamp, message)
session.commit()
except Exception:
session.rollback()
raise
finally:
session.close()
def on_return(self, task):
"""Called by main thread on the return of data from the workers.
Post-processing"""
logger.info("Retrieved task %s", task.tag)
traj = Session.query(models.Trajectory).get(int(task.tag))
try:
# save lh5 version of the trajectory
conf = load_file(self.project.pdb_topology_file)
coordinates = msmbuilder.Trajectory.load_trajectory_file(str(traj.dry_xtc_fn), Conf=conf)
save_file(traj.lh5_fn, coordinates)
except Exception as e:
logger.error("When postprocessing %s, convert to lh5 failed!", traj)
logger.exception(e)
raise
# convert last_wet_snapshot to lh5
pdb_to_lh5(traj, "last_wet_snapshot_fn")
pdb_to_lh5(traj, "init_pdb_fn")
traj.host = task.host
traj.returned_time = datetime.now()
traj.length = len(coordinates)
Session.flush()
Session.commit()
logger.info("Finished converting new traj to lh5 sucessfully")
def load(file_path):
if not file_path.endswith('xml'):
print('Not an XML file:' + file_path)
pass
if file_path.endswith('DIY.xml'):
author, title, sections = parse_xml(open(file_path))
else:
author, title, sections = parse_perseus(open(file_path),'div1')
session = Session()
a = get_or_create(session, Author, name=author)
session.commit()
t = get_or_create(session, Text, name=title, author=a.id)
session.commit()
global_ngrams = session.query(GlobalNgrams).first()
section_count = 1
log('Loading: ' + t.name)
if not USE_ORIGINAL_DIVISIONS:
sections = [' '.join(sections)]
if DIVISION_LENGTH:
sections = create_chunks(sections[0],DIVISION_LENGTH)
for sec in sections:
temp_section = get_or_create(session, Section, source_text=t.id, number=section_count)
log('Loading section ' + str(section_count))
session.commit()
temp_section_content = get_or_create(session, SectionContent, section = temp_section.id, content = sec)
log('Creating ngrams of ' + str(section_count))
temp_section_ngrams = get_or_create(session, SectionNgrams, section = temp_section.id, ngrams = generate_ngrams(temp_section_content.content))
log('Updating global ngram counts.')
update_global_counts(session, global_ngrams,temp_section_ngrams.ngrams)
section_count = section_count + 1
session.commit()
update_vector_space(session, global_ngrams)
def main():
Base.metadata.create_all(engine)
session = Session()
video_fetcher = VideoFetcher('a', 10)
video_fetcher.get_new_views_for_existing_videos(session)
video_fetcher.get_new_videos(session)
session.commit()
def main():
reading_id = int(sys.argv[1])
session = Session()
reading = session.query(Reading).filter(Reading.id == reading_id).one()
text = reading.text
PrependStream(sys.stdout, ' ').write('"' + text.strip() + '"')
sys.stdout.write('\n')
session.rollback()
def index():
if session.get('logged_in'):
return redirect(url_for('main'))
new = Session.query(music).order_by(music.id.desc())[0:10]
most = Session.query(music).order_by(music.count.desc())[0:10]
return render_template('login.html', most=most, new = new)
def login_check(user_name):
session = Session()
user = session.query(User).filter(or_(
User.nickname == user_name)).first()
print session
session.commit()
if not user:
return None
return user
def albuminfo (): data = request.get_json() album1 = Session.query(album).filter(album.id==data['id']).one() json_data = dict(id = data['id'] ,name=album1.name,singer=album1.singer, url=album1.name+'.jpg', musicnum = album1.music_count) musiclist1=[] for m in Session.query(music).filter(music.albumid==data['id']).order_by(music.num).all(): musiclist1.append(m.diction()) json_data ["musiclist"] =musiclist1 return jsonify(json_data)
def check_db(loud=False, delete_orphans=False, fix=False):
session = Session()
check_orphans(session, loud, delete_orphans)
check_readings(session, loud, fix)
check_masses(session, loud)
check_events(session, loud)
#session.commit()
session.rollback()
session.close()
def submit(self, traj):
""" Submit a job to the work-queue for further sampling.
Parameters
----------
"""
if traj.submit_time is not None:
raise ValueError("This traj has already been submitted")
Session.add(traj)
Session.flush()
traj.populate_default_filenames()
if not hasattr(traj, 'init_pdb'):
raise ValueError('Traj is supposed to have a pdb object tacked on')
save_file(traj.init_pdb_fn, traj.init_pdb)
remote_driver_fn = os.path.split(str(traj.forcefield.driver))[1]
remote_pdb_fn = 'input.pdb'
remote_output_fn = 'production_dry{}'.format(traj.forcefield.output_extension)
if traj.mode is None or traj.forcefield is None:
raise ValueError('malformed traj')
task = Task('chmod +x ./{driver}; ./{driver} {pdb_fn} {ff} {water} {mode} {threads}'.format(
pdb_fn=remote_pdb_fn,
mode=traj.mode,
driver=remote_driver_fn,
ff=traj.forcefield.name,
water=traj.forcefield.water,
threads=traj.forcefield.threads))
#why does traj.forcefield.driver come out as unicode?
task.specify_input_file(str(traj.forcefield.driver), remote_driver_fn)
task.specify_output_file(traj.wqlog_fn, 'logs/driver.log')
task.specify_input_file(traj.init_pdb_fn, remote_pdb_fn)
task.specify_output_file(traj.dry_xtc_fn, remote_output_fn)
if self.return_wet_xtc:
# this is the XTC file with waters, generated by the driver
# when you're doing implicit solvent only, this stuff is not used.
remote_wet_output_fn = 'production_wet{}'.format(traj.forcefield.output_extension)
task.specify_output_file(traj.wet_xtc_fn, remote_wet_output_fn)
task.specify_output_file(traj.last_wet_snapshot_fn, 'last_wet_snapshot.pdb')
else:
logger.debug('Not requesting production_wet%s from driver (implicit)', traj.forcefield.output_extension)
task.specify_tag(str(traj.id))
task.specify_algorithm(WORK_QUEUE_SCHEDULE_FILES) # what does this do?
traj.submit_time = datetime.now()
self.wq.submit(task)
logger.info('Submitted to queue: %s', traj)
def getlist(): data = request.get_json() item = Session.query(playlist_item).filter(playlist_item.listid==data['id']).order_by(playlist_item.order).all() json_data = dict(id = data['id']) musiclist = [] for m in item: mm = m.music.diction() mm["order"] = m.order musiclist.append(mm) json_data ["name"] = Session.query(playlist.name).filter(playlist.id==data['id']).first() json_data ["musiclist"] =musiclist return jsonify(json_data)
def add_forcefields_to_db(self, p):
if Session.query(models.Forcefield).count() == 0:
# add forcefields
for ff in p:
obj = models.Forcefield(**ff)
obj.driver = os.path.join(self.params_dir, ff['driver'])
Session.add(obj)
Session.commit()
else:
print "NOTE: I'M NOT PARSING NEW FORCEFIELDS"
def delete_user(self, user_id):
s = Session()
del_user = s.query(User).filter(User.id == user_id).one()
s.delete(del_user)
s.commit()
self.signal_delete_user.emit(user_id)
s.close()
async def update_user(user_id: int, User: UserUpdate,
db: Session = Depends(get_db), current_user: \
User = Depends(get_current_active_user)):
try:
if not db.query(UserModel).filter(UserModel.id == user_id).first():
return failedMessage('Registro no existe')
res = db.query(UserModel).filter(UserModel.id == user_id).\
update({UserModel.name: User.name, UserModel.email: User.email})
db.commit()
model_dict = model2Dict(
db.query(UserModel).filter(UserModel.id == user_id).first())
res = UserResponse(**model_dict)
except SQLAlchemyError as e:
raise Exception(e)
return res
def most_frequent_duos(frequent_words):
from datamodel import Link
from database import Session
s=Session()
links=s.query(Link)
duos={}
for l in links:
#t=tokenize(l.title)
t=mash_post(l)
for w in t:
if w in frequent_words:
for w2 in t:
if w!=w2 and w2 in frequent_words:
dic_add(duos,frozenset((w,w2)))
return [list(s) for s,f in duos.items() if f>10]
def echo_controller(request):
data = request.get('data')
session = Session()
message = Message(data=data.get('text'))
session.add(message)
session.commit()
session.close()
return make_response(request, 200, data)
def get_all_messages():
"""
Function to get all messages fron DB
:return: non-filtered list of all messages in DB
"""
session = Session()
messages = reduce(
lambda value, item: value +
[{
'content': item.content,
'created': item.created.strftime("%Y-%m-%d-%H.%M.%S")
}],
session.query(Message).all(), [])
return messages
def dump_articles():
session = Session()
articles = session.query(Article).filter(
Article.term.in_(settings.SCRAPE_TERMS)).all()
headers = ["term"] + settings.ARTICLE_OUTPUT_FIELDS
article_list = [headers]
for a in articles:
article_list_item = [a.term]
data = json.loads(a.data)
for field in settings.ARTICLE_OUTPUT_FIELDS:
article_list_item.append(extract_field(data, field))
article_list.append(article_list_item)
with open(settings.OUTPUT_CSV_PATH, "w+") as csvfile:
wr = csv.writer(csvfile)
wr.writerows(article_list)
def delete_account(password=Form(...),
user=Depends(manager),
db: database.Session = Depends(database.get_db)):
if not user:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
detail='Not authenticated')
else:
db_user = db.query(
database.User).filter_by(username=user.username).first()
if database.Hash.verify_password(password, db_user.password):
db.delete(db_user)
db.commit()
return {'detail': 'Account deleted successfully.'}
else:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
detail='Account password is incorrect')
def __init__(self, parent=None):
super(QtWidgets.QDialog, self).__init__(parent)
self.setupUi(self)
self.session = Session()
self.encounterDate.setDate(datetime.now())
self.buttonBox.clicked.connect(self.clickapply)
def test_request_new_order(fresh_database):
with app.test_client() as test_client:
with requests_mock.Mocker(real_http=True) as m:
m.get(re.compile("/manage/health"), text='')
m.post(re.compile("/api/v1/warehouse"),
json={
"orderItemUid": "item-1",
"orderUid": "1-1-1",
"model": "Lego 8880",
"size": "L"
})
m.post(re.compile("/api/v1/warranty/item-1"))
response = test_client.post("/api/v1/orders/1",
json={
"orderUid": "1-1-1",
"model": "Lego 8880",
"size": "L"
})
assert response.status == "200 OK"
assert response.json["orderUid"]
with Session() as s:
order = (s.query(Order).filter(
Order.order_uid == response.json["orderUid"]).one_or_none())
assert order
assert order.order_uid == response.json["orderUid"]
def printSights():
#Вывод данных
data = Session.query(Sight)
for row in data:
print("\"{}\" год: {} Область: {} Страна: {}".format(
row.name, row.year, row.state.name, row.state.country.name))
class Set(Base):
__tablename__ = 'sets'
__table_args__ = (UniqueConstraint('id', sqlite_on_conflict='IGNORE'), )
session = Session()
id = Column(String, primary_key=True)
code = Column(String, unique=True)
name = Column(String, unique=True)
release_date = Column(Date, nullable=True)
card_count = Column(Integer)
set_type = Column(String)
printings = relationship('Printing', back_populates='set')
@classmethod
def from_code(cls, code):
q = cls.session.query(cls).filter(cls.code == code)
return q.first()
@classmethod
def from_scryfall(cls, data):
mapping = {'released_at': 'release_date'}
data = util.convert(data, mapping)
data['release_date'] = date.fromisoformat(data['release_date'])
col_names = [c.name for c in Set.__table__.columns]
return Set(**util.restriction(data, col_names))
def is_regular(self) -> bool:
regular_set_types = ('core', 'expansion', 'masters',
'draft_innovation')
return self.set_type in regular_set_types
def usersocial(id):
user1 = Session.query(user).filter(user.id == id).first()
if request.method == 'POST':
post = True
else :
post = False
group1 = [
dict(name=u"애픽하이"),
]
feedlist = Session.query(feed).filter(feed.userid==id).order_by(feed.id.desc()).all()
user1 = dict(name=user1.realname, grouplist = group1, profileurl = session['profile'])
return render_template('social.html', user = user1, feedlist = feedlist, post=post)
def users(user_id):
form = AboutMeForm()
session = Session()
user = session.query(User).filter(User.id == user_id).first()
if not user:
flash("The user is not exist.")
redirect("/index")
blogs = user.posts
return render_template(
"user2.html",
form=form,
user=user,
blogs=blogs)
def get_folders(course):
'''Gets all folders
'''
session = Session()
try:
r = s.get('https://edux.pjwstk.edu.pl/Folder.aspx')
r.raise_for_status()
new_folders = extract_folders(r.content)
for (folder_id, title, start_at, finish_at) in new_folders:
folder = session.query(Folder). \
filter_by(folder_id=folder_id). \
first()
if folder is None:
folder = Folder(
folder_id=folder_id,
course=course,
title=title,
start_at=start_at,
finish_at=finish_at)
send_notify('New folder "{}" at {}'.format(title,
course.title),
'''Folder title: {0.title}
Start at: {0.start_at}
Finish at: {0.finish_at}'''.format(folder))
session.add(folder)
if (folder.title != title or
folder.start_at != start_at or
folder.finish_at != finish_at):
new = {
'title': title,
'start_at': start_at,
'finish_at': finish_at
}
send_notify('Folder "{0}" updated'.format(title),
'''Folder title: {new[title]} (old: {0.title})
Start at: {new[start_at]} (old: {0.start_at})
Finish at: {new[finish_at]} (old: {0.finish_at})'''.format(folder,
new=new))
folder.title = title
folder.start_at = start_at
folder.finish_at = finish_at
session.add(folder)
session.commit()
finally:
session.close()
def update_sets(verbose=True):
sets = scryfall.Request("sets").data
session = Session()
known_ids = [t[0] for t in session.query(Set.id).all()]
for s in sets:
if s['id'] not in known_ids:
session.add(Set.from_scryfall(s))
if verbose:
print(
f"New set: {s['name']} ({s['code']} [{s['card_count']} cards])"
)
session.commit()
session.close()
def view_job(job_id):
job = Session().query(Job).get(job_id)
if job == None: raise click.ClickException('No job found')
table_data = [['Date', job.created_date], ['Job ID', job.id],
['Node', job.node], ['Exit Code', job.exit_code],
['Tool', job.batch.name()], ['STDOUT', job.stdout],
['STDERR', job.stderr]]
display_table([], table_data)
def for_name(cls, name, create=False):
try:
return Session.query(cls).filter_by(name=name).one()
except NoResultFound:
if create:
return returnit(Session.add, cls(name))
else:
raise EventNotFound(name)
def socket_ping(data):
# We pull the user id ourselves to avoid excessive DB queries
if request.cookies.get("sid"):
s = Session.find(request.cookies.get("sid"))
if s:
redis.set("user:%s:ping" % s['user'], time.time())
if 'lobby' in data:
redis.set("user:%s:lobby:%s:ping" % (s['user'], data['lobby']), time.time())
def test_request_start_warranty(fresh_database):
with app.test_client() as test_client:
response = test_client.post("/api/v1/warranty/1-1-1")
assert response.status_code == 204
with Session() as s:
created_warranty = s.query(Warranty).filter(
Warranty.item_uid == "1-1-1").one_or_none()
assert created_warranty.status == Status.on
def clear_db(request):
engine = Session().get_bind()
def reset_db():
Base.metadata.drop_all(bind=engine)
Base.metadata.create_all(bind=engine)
request.addfinalizer(reset_db)
def update_email(email=Form(...),
user=Depends(manager),
db: database.Session = Depends(database.get_db)):
if not user:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
detail='Not authenticated')
else:
if len(email) >= 75:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail='Email is too long')
else:
db_user = db.query(
database.User).filter_by(username=user.username).first()
db_user.email = email
db.commit()
db.refresh(db_user)
return {'detail', 'Email successfully changed'}
def step_impl(context):
clients = Session.query(Client).filter(
Client.id == context.client_id
).one()
assert str(clients.ip) == "192.168.1.104"
assert str(clients.port) == "22"
assert str(clients.username) == "jahanzaib"
def db_session() -> Iterator[Session]:
session = Session()
try:
yield session
session.commit()
except Exception:
session.rollback()
raise
finally:
session.close()
def update_cards(verbose=True):
session = Session()
bulk_data_uri = scryfall.get_bulk_data()
bulk_data = scryfall.bulk_data_generator(bulk_data_uri)
printings = (Printing.from_scryfall(p) for p in bulk_data)
session.add_all(printings)
with warnings.catch_warnings():
warnings.simplefilter('ignore', category=exc.SAWarning)
session.commit()
session.close()
def del_user_controller(request):
user_id = int(request.get('id'))
session = Session()
for each_user in session.query(User).filter_by(id=user_id):
session.delete(each_user)
session.commit()
return make_response(request, 200, f'User id {user_id} deleted')
def process_program(self, id: int) -> Optional[str]:
session = Session()
program = session.query(Program).filter(Program.id == id).one_or_none()
if not program:
return
state_db = Mongo(STATE_COLL)
parameters = program.parameters
rating = 0
for param in parameters:
rating += param['weight'] * int(
param['value']) # TODO: type processing
program.rating = int(rating) # round score
session.add(program)
session.commit()
state_db.update_one({'key': PROCESS_KEY}, {'$pull': {'planned': id}})
stats_db = Mongo(STATS_COLL)
return f'New rating for program <{id}>: {rating}'
def count(id):
logger.info(f'Adding task for id: {id}')
session = Session()
task = session.query(Tasks).filter_by(id=id).first()
res = Results(address=task.address, words_count=0, http_status_code=0)
try:
scrpr = Scrapper(task.address)
except:
scrpr = None
if scrpr:
err = scrpr.get_page()
if not err:
task.http_status_code, matches = scrpr.count_matches()
task.task_status = 'FINISHED'
res = Results(address=task.address,
words_count=matches,
http_status_code=task.http_status_code)
else:
print(err)
session.add(res)
session.commit()
logger.info(task)
logger.info(res)
async def iterate_companies(self, session: database.Session):
for index_company, company in enumerate(session.query(Company).all()):
res = company.iterate()
if res:
self.stock_increase.append(True)
shares = session.query(
database.Shares).filter_by(company_id=company.id)
for share in shares:
user = session.query(User).get(share.user_id)
cost = user.passive_income(company=company,
session=session)
# cost = math.ceil(share.amount*company.stock_price)
# user = session.query(User).get(share.user_id)
# income_percent = 0.10
# total_shares = sum(share.amount for share in user.shares if share.company_id == company.id)*company.stock_price
# income_percent -= (total_shares/5_000)/100
# cost = math.ceil(cost * max(income_percent, 0.01))
await self.api.upgraded_add_points(user, cost, session)
session.commit()
else:
if not company.abbv == 'DFLT':
company.bankrupt = True
self.names[company.abbv] = company.full_name
session.commit()
self.start_company_events(session)
def toggle_task(update: Update, context: CallbackContext) -> None:
user_id = update.callback_query.from_user.id
callback_query = update.callback_query
message_keyboard_markup = callback_query.message.reply_markup.inline_keyboard
event, task_id = callback_query.data.split(":")
for i in range(len(message_keyboard_markup)):
if message_keyboard_markup[i][0].callback_data == callback_query.data:
session = Session()
user_task = session.query(UserTask)\
.filter(UserTask.id == task_id)\
.filter(UserTask.tg_user_id == user_id)\
.first()
if user_task is not None:
user_task.completed = not user_task.completed
message_keyboard_markup[i][0] = \
InlineKeyboardButton(format.task(user_task), callback_data=f"UserTask_toggle_click:{user_task.id}")
session.commit()
else:
del message_keyboard_markup[i]
session.close()
break
context.bot.edit_message_reply_markup(
chat_id=update.effective_chat.id,
message_id=update.callback_query.message.message_id,
reply_markup=InlineKeyboardMarkup(message_keyboard_markup))
update.callback_query.answer()
def insert_test_values():
from database import Session
from database.objects import User, Address, BlogPost, Keyword
from random import randint
letters = "abcdefghijklmnopqrstuvwxyz"
s = Session()
keyword = Keyword("firstpost")
for n in range(100):
name = ""
for l in range(randint(4, 10)):
letter = letters[randint(0, len(letters) - 1)]
name += letter
user = User(name=name, fullname=name, password="******")
user.addresses = [
Address(email_address=("*****@*****.**" % name)),
Address(email_address=("*****@*****.**" % name)),
]
post = BlogPost(("%ss Blog Post" % name), "This is a test", user)
post.keywords.append(Keyword(name))
post.keywords.append(keyword)
s.add(post)
s.commit()
s.close()
def search(search_query: str, db: database.Session = Depends(database.get_db)):
result = db.query(database.Listing).filter(
database.or_(database.Listing.context.contains(search_query),
database.Listing.title.contains(search_query))).all()
if not result:
raise HTTPException(status.HTTP_404_NOT_FOUND,
detail=f'No listing contained: \'{search_query}\'')
else:
return result
def search_message_controller(request):
errors = {}
is_valid = True
data = eval(request.get('data'))
if not 'keyword' in data:
errors.update({'keyword': 'Attribute is required'})
is_valid = False
if not is_valid:
return make_response(request, 400, {'errors': errors})
keyword = '%' + data.get('keyword') + '%'
session = Session()
messages = reduce(
lambda value, item: value + [{
'data': item.data,
'created': item.created.timestamp()
}],
session.query(Message).filter(Message.data.ilike(keyword)).all(), [])
return make_response(request, 200, messages)
def attributes(self):
return [
x
for x, in Session.query(Attribute.key)
.join(Attribute.entry)
.filter_by(event_id=self.id)
.order_by(Attribute.key)
.distinct()
]
def inbox(user=Depends(manager),
db: database.Session = Depends(database.get_db)):
if not user:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
detail='Not authenticated')
else:
inbox = db.query(
database.Messages).filter_by(recipent=user.username).all()
return inbox
def test_load_from_database(self):
game = Briscola4Game('debug', Session())
disp = DebugDispatcher(game)
self.assertEqual(game.running, False)
print 'ok'
disp.input('1') #Seed
disp.input('Alberto')
disp.input('Barbara')
disp.input('Carlo')
disp.input('Diana')
game.save()
session = Session()
game2 = session.query(Game).filter_by(name='debug').first()
game2.initialize_default_properties(session)
disp2 = DebugDispatcher(game2)
disp2.input('7C')
def categories(db: Session = Depends(get_db)):
# Leo todas las categorías
categories = db.query(models.Category).all()
# Leo las categorías usando la sintaxis ORM de SQLAlchemy
cats = [
schema.Category(id=id, name=category.name)
for id, category in enumerate(categories)
]
return {"categories": cats}
def get_listing(id: int, db: database.Session = Depends(database.get_db)):
listing = db.query(database.Listing).filter_by(id=id).first()
if listing == None:
raise HTTPException(status.HTTP_404_NOT_FOUND,
detail='Requested listing not found')
else:
return models.Listing(post_id=str(id),
title=listing.title,
author=listing.author,
context=listing.context)
def add_some_order():
with Session() as s:
s.add(
Order(
item_uid="item-1",
order_date=date.today(),
order_uid="1-1-1",
status="PAID",
user_uid="1",
))
def index(self, fullname=None, username=None, password=None):
if cherrypy.request.method == "POST":
session = Session()
new_user = User(username, fullname, password)
session.add(new_user)
session.commit()
session.close()
raise cherrypy.HTTPRedirect("/")
def add_user(self, name, address):
if not (name == '' or address == ''):
s = Session()
u = User(name=name, fullname='%s test' % name, password='******')
u.addresses = [Address(email_address=address), ]
s.add(u)
s.commit()
self.send_user(u)
s.close()
def index(self, username=None):
tableText = '<div class="container">\n\
<table class="table">\n\
<thead>\n\
<tr>\n\
<th>Name</th>\n\
<th>Username</th>\n\
<th>Password</th>\n\
</tr>\n\
</thead>\n\
<tbody>\n'
session = Session()
if username == None:
for user in session.query(User).order_by(User.id):
tableText += (
"<tr>\n<td>"
+ user.fullname
+ "</td>\n"
+ "<td>"
+ user.username
+ "</td>\n"
+ "<td>"
+ user.password
+ "</td>\n</tr>\n"
)
else:
for user in session.query(User).filter(User.username.like("%" + username + "%")).order_by(User.id):
tableText += (
"<tr>\n<td>"
+ user.fullname
+ "</td>\n"
+ "<td>"
+ user.username
+ "</td>\n"
+ "<td>"
+ user.password
+ "</td>\n</tr>\n"
)
tableText += "</tbody>\n</table>\n"
session.close()
return top + tableText + bottom
def main():
if not session.get('logged_in'):
return redirect(url_for('index'))
if request.method == 'POST':
post = True
else :
post = False
albumlist1 = Session.query(album).order_by(album.id).all()
return render_template('album_view.html', albumlist=albumlist1, post=post)
def most_frequent_words():
"""Return all 'interesting' words"""
from datamodel import Link
from database import Session
s=Session()
links=s.query(Link)
frequent={}
for l in links:
#words=tokenize(l.title)
words=mash_post(l)
for w in words:
if frequent.has_key(w):
frequent[w]+=1
else:
frequent[w]=1
fwords= [(f,w) for w,f in frequent.items() if f>=4 and (f<=20 or w[:4]=="http") and len(w)>1]
fwords.sort(reverse=True)
maxlength=800
if len(fwords)>maxlength:
fwords=fwords[:maxlength]
return [w for f,w in fwords]
def main():
session = Session()
if len(sys.argv[1:]) == 1:
mass_id = int(sys.argv[1])
masses = [session.query(Mass).filter(Mass.id == mass_id).one()]
elif len(sys.argv[1:]) == 3:
year, month, day = map(int, sys.argv[1:])
lit_years = {}
lit_date = get_lit_date(datetime.date(year, month, day), lit_years, session)
masses = lit_date.get_masses(strict=True)
else:
print >> sys.stderr, "Wrong number of arguments"
sys.exit(1)
fout = PrependStream(sys.stdout, '# ')
for mass in sorted(masses, key=lambda x: x.order):
num_reading = max(map(lambda x: x.order, mass.readings)) + 1
quotes = []
alt_quotes = []
print >> fout, "Mass #%d (%s) in event %s - ID: %d" % (mass.order, mass.title, mass.event.title, mass.id)
for reading in sorted(mass.readings, key=lambda x: (x.order, x.alt_num)):
print >> fout, " Lettura #%d.%d (%s): %s - ID: %d" % (reading.order, reading.alt_num, reading.title, reading.quote, reading.id)
for i in xrange(num_reading):
[reading] = filter(lambda x: x.order == i and x.alt_num == 0, mass.readings)
if reading.only_on_sunday:
alt_quotes[0].append(reading.quote)
continue
quotes.append(reading.quote)
alt_quotes.append(map(lambda x: x.quote, sorted(filter(lambda x: x.order == i and x.alt_num > 0, mass.readings), key=lambda x: x.alt_num)))
sys.stdout.write("citazioni: %s\n" % (json.dumps(quotes)))
sys.stdout.write("citazioni_alt: %s\n" % (json.dumps(alt_quotes)))
session.rollback()
