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()