def setUp(self): self.account_info = { "name": "Fiona", "password": "******", "gender": 'F', "weight": 56, "height": 176, "activity_level": 3, "age": 23, "recomended_calories": 0, "recomended_proteins": 0, "recomended_carbs": 0, "recomended_fats": 0, "percent_proteins": 0.4, "percent_carbs": 0.4, "percent_fats": 0.2 } self.tester_account = Account(models.connect()) self.tester_account.add(self.account_info) self.account = self.tester_account.get_by_name("Fiona") self.tester = ConsumedFood(models.connect()) self.multiplier = 3.5 self.info = { "name": "peanut butter", "quantity": 100, "calories": 578, "proteins_g": 29.1, "carbs_g": 11.8, "fats_g": 46.1 }
def open(self, user_oid, username): models.connect() self.subscribe_pk = None try: user = models.User.objects.get(pk=user_oid) if username == user.username: self.user = user else: self.user = None except: self.user = None print(user_oid, username) print(self.user) if username == "admin" and self.user == None: if settings.HERMES_API_KEY.split('-')[0] == user_oid: class Admin: def __init__(self): self.owner = 0 self.is_admin = True self.user = Admin() if not self.user: return self.runCallback('open', None)
def eomReceived(self): header = "" header_done = False message = "" for line in self.lines: if header_done: message += line + "\r\n" continue if line == "": header_done = True continue header += line + "\r\n" thisHeader = line.split(": ", 1) headers = Parser().parsestr(header) self.lines = None connect() domain = get_or_create_domain(self.user.dest.domain) user = get_or_create_user(self.user.dest.local, domain) Mail(user=user, ts=datetime.datetime.now(), envelopeHeloHost=self.user.helo[0], envelopeHeloAddress=self.user.helo[1], envelopeFrom=str(self.user.orig), envelopeTo=str(self.user.dest), headerFrom=headers["from"] or "", headerSubject=headers["subject"] or "", headers=header, body=message) return defer.succeed(None)
def eomReceived(self): header = "" header_done = False message = "" for line in self.lines: if header_done: message += line + "\r\n" continue if line == "": header_done = True continue header += line + "\r\n" thisHeader = line.split(": ", 1) headers = Parser().parsestr(header) self.lines = None connect() domain = get_or_create_domain(self.user.dest.domain) user = get_or_create_user(self.user.dest.local, domain) Mail( user = user, ts = datetime.datetime.now(), envelopeHeloHost = self.user.helo[0], envelopeHeloAddress = self.user.helo[1], envelopeFrom = str(self.user.orig), envelopeTo = str(self.user.dest), headerFrom = headers["from"] or "", headerSubject = headers["subject"] or "", headers = header, body = message ) return defer.succeed(None)
def _main(): cli = _get_cli() models.connect(recreate=cli.recreate) for listener in settings.SCANS: if listener.get('enabled', True): _process_listener(listener, cli.log)
def get(self): models.connect() users = {"users": models.HermesUser.objects().to_json()} self.set_header('Content-Type', 'application/json') self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN) self.set_header("Access-Control-Allow-Credentials", "true") self.write(users)
def __call__(self, environ, start_response): self.request = Request(environ) handler, args = self.find_handler() if not handler: raise HTTPNotFound('No handler defined for %s (%s)' % (self.request.path_info, self.request.method)) if not args: args = () # Prepare database connection connect() response = handler(self, self.request, *args) if not response: response = Response() # Provide an empty response # Base WSGI app shoud be session agnostic # self.session = dict() # # if SESSION_KEY in environ: # self.session = environ[SESSION_KEY] # else: # self.session = {} # Fail soft #log.debug('Response for call %s is %s' % (self.request.path_info, type(response))) return response(environ, start_response)
def __call__(self, environ, start_response): connect() # New session manager instance each time manager = SessionManager(environ, **self.kwargs) # Add a session object to wrapped app self.app.session = manager.session #environ[SESSION_KEY] = manager.session # Initial response to a cookie session def initial_response(environ, start_response): def session_response(status, headers, exc_info=None): manager.set_cookie(headers) return start_response(status, headers, exc_info) return self.app(environ, session_response) try: # Return initial response if new or session id is random if manager.is_new: return initial_response(environ, start_response) return self.app(environ, start_response) # Always close session finally: manager.close()
def get(self): models.connect() users = { "users": models.HermesUser.objects().to_json() } self.set_header('Content-Type', 'application/json') self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN) self.set_header("Access-Control-Allow-Credentials", "true") self.write(users)
def update_all(): t = tvdb_api.Tvdb() db = models.connect() shows = db.query(Show).all() for s in shows: add_episodes(s.show_id, t, db, True) db.remove()
def SearchDbForShow(list_of_shows): db = models.connect() source = db.query(ScanURL).filter(ScanURL.media_type == "index").first() if source: browser = LinkRetrieve.source_login(source) if browser is None: ActionLog.log('%s could not logon' % source.login_page) else: for show_searcher in [l for l in list_of_shows if not l.retrieved]: config = db.query(models.Config).first() matching_indexes = [] for search_text in show_searcher.search_list: # all potential links to list matching_indexes.extend(db.query(LinkIndex).filter(LinkIndex.link_text.like('%' + search_text + '%')).filter(LinkIndex.link_text.like('%' + show_searcher.episode_code + '%')).all()) if len(matching_indexes) > 0: for match in matching_indexes: tv_response = browser.get(match.link_url) if tv_response.status_code == 200: episode_soup = tv_response.soup episode_links = LinkRetrieve.get_download_links(episode_soup, config, source.domain, config.hd_format) # check to make sure links are active for l in episode_links: link_response = browser.get(l) if link_response.status_code == 404: episode_links = None break if episode_links: LinkRetrieve.process_tv_link(db, config, show_searcher, episode_links) break # since we got the download, we can break out of the loop
def add_episodes(series_id, t=None, db=None, is_mass_update=False): if t is None: t = tvdb_api.Tvdb() if db is None: db = models.connect() episodes = t[series_id].search('') update_show = db.query(Show).filter(Show.show_id == series_id).first() update_show.banner = t[series_id]['banner'] if t[series_id]['banner'] != None else '' models.ActionLog.log('Updating "%s"' % update_show.show_name) update_show.episodes.delete() db.commit() # if update_show.episodes.count() > 0: # # update unaired show first with new names & air date # for db_episode in [s for s in update_show.episodes if s.status == 'Pending']: # # find the episode ID in tv_db episode listing # updated_episode_list = [x for x in episodes if x['id'] == str(db_episode.id)] # if len(updated_episode_list) > 0: # updated_episode = updated_episode_list[0] # db_episode.air_date = None if updated_episode['firstaired'] is None else \ # datetime.datetime.strptime(updated_episode['firstaired'], '%Y-%m-%d').date() # db_episode.episode_name = str(updated_episode).replace('<', '').replace('>', '') # # # get episodes that aren't in the show's episode collection but are in the tvdb response # episodes = [x for x in episodes if update_show.episodes.filter(Episode.id == int(x['id'])).count() == 0 and x['seasonnumber'] != '0'] for e in episodes: if e['seasonnumber'] == '0': continue else: if e['firstaired'] is None: first_aired = None else: first_aired = datetime.datetime.strptime(e['firstaired'], '%Y-%m-%d').date() if is_mass_update: if first_aired is not None and first_aired >= datetime.date.today(): episode_retrieved = 'Pending' else: episode_retrieved = 'Retrieved' else: if first_aired is not None and first_aired >= datetime.date.today() + datetime.timedelta(-2): episode_retrieved = 'Pending' elif first_aired is None: episode_retrieved = 'Pending' else: episode_retrieved = 'Retrieved' new_episode = Episode(id=e['id'], season_number=e['seasonnumber'], episode_number=e['episodenumber'], air_date=first_aired, episode_name=str(e).replace('<', '').replace('>', ''), status=episode_retrieved, show=update_show) db.add(new_episode) db.commit()
def __call__(self, environ, start_response): self.request = Request(environ) handler, args = self.find_handler() if not handler: raise HTTPNotFound('No handler defined for %s (%s)' % (self.request.path_info, self.request.method)) if not args: args = () # Prepare database connection connect() response = handler(self, self.request, *args) if not response: response = Response() # Provide an empty response return response(environ, start_response)
def get_user(cls, email=None, id=None): """ Returns a dictionary of the user data. Must provide either an email or an id. """ db = connect() try: #logging.info('Attempting to get the user via the email ' + str(email) + ' or the id ' + str(id) + '.') query = db.query(_User) if email is not None: query = query.filter(_User.email == email) elif id is not None: query = query.filter(_User.id == id) else: raise AttributeError( 'You must supply an email or user_id (from the database) in order to get the user.' ) user = query.one().__dict__ user['sold'] = db.query(_Transaction).filter( _Transaction.seller_id == user['id']).count() user['purchased'] = db.query(_Transaction).filter( _Transaction.buyer_id == user['id']).count() user['listed_for_sale'] = db.query(_BookListing).filter( _BookListing.user_id == user['id']).filter( _BookListing.listing_type == 'For Sale').filter( _BookListing.active == '1').count() user['listed_for_purchase'] = db.query(_BookListing).filter( _BookListing.user_id == user['id']).filter( _BookListing.listing_type == 'Wanted').filter( _BookListing.active == '1').count() user['reviews'] = db.query( _UserReview.rating, _UserReview.comments, _UserReview.date_posted, _User.first_name, _User.last_name, _User.email, _User.username, _User.id).join( _User, _User.id == _UserReview.reviewer_id).filter( _UserReview.reviewee_id == user['id']).all() db.close() #print(user) return user except NoResultFound: logging.info('User not found.') db.close() return None except MultipleResultsFound: logging.debug( 'Multiple accounts found for this email, this shouldn\' happen.... :-(' ) db.rollback() db.close() return False except: logging.debug( 'A different error occured than was expected.... What to do?') db.rollback() db.close() raise return None
def setUp(self): self.tester = Food(models.connect()) self.info = { "name": "peanut butter", "quantity": 100, "calories": 578, "proteins_g": 29.1, "carbs_g": 11.8, "fats_g": 46.1 }
def post(self): """ creates new HermesUser object >>> POST /api/v1/users {"api_key":<settings.HERMES_API_KEY>, "owner":<model.HermesUser.pk>, "username":<model.HermesUser.username>, "i_am": <profile_type> } <<< { "oid":"XXXXXXXXXXXXXXX", "user": <models.HermesUser> } On errors: <<< {} """ api_key = self.get_argument("api_key") if api_key != settings.HERMES_API_KEY: self.write({}) owner = self.get_argument("owner") username = self.get_argument("username") is_admin = eval(self.get_argument('is_admin')) is_moderator = eval(self.get_argument('is_moderator')) is_expert = eval(self.get_argument('is_expert')) print(is_admin, is_moderator, is_admin) models.connect() models.User.objects(owner=owner).delete() user = models.User(owner=owner, username=username, is_admin=is_admin, is_expert=is_expert, is_moderator=is_moderator) user.save() output = { "oid": str(user.pk), "user": user.to_json() } print("Created" + user.to_json()) self.set_header('Content-Type', 'application/json') self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN) self.set_header("Access-Control-Allow-Credentials", "true") self.write(output)
def post(self): """ creates new HermesUser object >>> POST /api/v1/users {"api_key":<settings.HERMES_API_KEY>, "owner":<model.HermesUser.pk>, "username":<model.HermesUser.username>, "i_am": <profile_type> } <<< { "oid":"XXXXXXXXXXXXXXX", "user": <models.HermesUser> } On errors: <<< {} """ api_key = self.get_argument("api_key") if api_key != settings.HERMES_API_KEY: self.write({}) owner = self.get_argument("owner") username = self.get_argument("username") is_admin = eval(self.get_argument('is_admin')) is_moderator = eval(self.get_argument('is_moderator')) is_expert = eval(self.get_argument('is_expert')) print(is_admin, is_moderator, is_admin) models.connect() models.User.objects(owner=owner).delete() user = models.User(owner=owner, username=username, is_admin=is_admin, is_expert=is_expert, is_moderator=is_moderator) user.save() output = {"oid": str(user.pk), "user": user.to_json()} print("Created" + user.to_json()) self.set_header('Content-Type', 'application/json') self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN) self.set_header("Access-Control-Allow-Credentials", "true") self.write(output)
def post(self): """ POST /api/v1/login {"oid":<models.HermesUser.oid>, "username":<model.HermesUser.username>} """ self.set_header('Content-Type', 'application/json') self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN) self.set_header("Access-Control-Allow-Credentials", "true") models.connect() pk = self.get_argument("oid") username = self.get_argument("username") user = models.HermesUser.objects(pk=pk) if not user: self.write({'login': False}) user = user[0] if user.username == username: self.write({'login': True}) else: self.write({'login': False})
def login(cls, user_name, password): if Account.match_user_password(cls.session, user_name, password): cls.session = connect() cls.food_record = Food(cls.session) cls.account = Account(cls.session) cls.consumed_food = ConsumedFood(cls.session) cls.statistics = Statistics(cls.session) cls.loaded_user = cls.account.get_by_name(user_name) cls.logged_in = True else: # Wrong account or password! return None
def __call__(self, environ, start_response): request = Request(environ) handler, args = self._find_handler(request) if not handler: raise HTTPNotFound('No handler defined for %s (%s)' % (request.path_info, request.method)) if not args: args = () # Save request object for handlers self.request = request self.application_url = request.application_url connect() response = handler(*args) if not response: response = Response() # Provide an empty response close() return response(environ, start_response)
def get_random_tunes(): engine, Session = connect() session = Session() # Get some random albums songs = session.query(Song).order_by(func.random()).limit(10).all() res = {"data": [song.to_dict() for song in songs]} res = {"data":[]} for song in songs: s = song.to_dict() s['album_title'] = song.album.title s['venue'] = song.album.venue res['data'].append(s) session.close() return jsonify(res)
def list(): """ Le listing et le formulaire d'ajout de todo """ db_session = connect(True) form = TodoForm() # GET de base pour obtenir les TODOS au départ data = { "todos": db_session.query(Todo).filter_by(done=0).all(), "form": form } return render_template("list.html", **data)
def __call__(self, environ, start_response): connect() # New session manager instance each time manager = SessionManager(environ, **self.kwargs) # Add a session object to wrapped app self.app.session = manager.session # Initial response to a cookie session def initial_response(environ, start_response): def session_response(status, headers, exc_info=None): manager.set_cookie(headers) return start_response(status, headers, exc_info) return self.app(environ, session_response) try: # Return initial response if new or session id is random if manager.is_new: return initial_response(environ, start_response) return self.app(environ, start_response) # Always close session finally: manager.close()
def ban_user(cls, user_id): try: db = connect() result = db.query(_User).filter(_User.id == user_id).one() result.is_banned = 1 db.commit() for listing in db.query(_BookListing).filter( _BookListing.user_id == user_id).all(): listing.active = 0 db.commit() db.close() except: db.rollback() db.close() raise
def change_admin(cls, user_id): try: db = connect() result = db.query(_User).filter(_User.id == user_id).one() if result.is_admin == 1: result.is_admin = 0 else: result.is_admin = 1 db.commit() db.close() except: db.rollback() db.close() raise return user_id
def setUp(self): self.tester = Account(models.connect()) self.account_password = Account.crypt("48da3cu7") self.info = { "name": "Fiona", "password": self.account_password, "gender": 'F', "weight": 56, "height": 176, "activity_level": 3, "age": 23, "recomended_calories": 0, "recomended_proteins": 0, "recomended_carbs": 0, "recomended_fats": 0, "percent_proteins": 0.4, "percent_carbs": 0.4, "percent_fats": 0.2 } self.tester.add(self.info)
def done(pk): # Controller pour rendre un TODO fait avec un post if pk: db_session = connect(True) current_todo = db_session.query(Todo).filter_by(id=pk).first() current_todo.done = True db_session.commit() data = { "id": pk } js_response = make_response( render_template("done.js", **data).replace("\n", "") ) js_response.headers["Content-Type"] = "text/javascript; charset=utf-8" return js_response return "", 400
def add_book(cls, google_id): """ Adds a book to the database, or checks whether it is already there. In either case, a book_id is returned. """ try: db = connect() query = db.query(_Book).filter(_Book.google_id == google_id) if query.count() > 0: result = query.first() return result.id book = cls.find_book(google_id=google_id) if book is None: return None if 'subtitle' not in book: book['subtitle'] = '' new_book = _Book( google_id=google_id, google_link=book['selfLink'], title=book['title'], subtitle=book['subtitle'], authors=book['authors'], publisher=book['publisher'], description=book['description'], ISBN_10=book['ISBN_10'], ISBN_13=book['ISBN_13'], pages=book['pageCount'], small_thumbnail=book['imageLinks']['smallThumbnail'], thumbnail=book['imageLinks'] ['thumbnail']) # published_date=book['publishedDate'], db.add(new_book) db.commit() book_id = new_book.id db.close() return book_id except: logging.debug("Something went wrong when inserting the book. :-(") db.rollback() db.close() raise
def startup(): conf = { '/': { 'tools.sessions.on': True, 'tools.staticdir.root': os.path.abspath(os.getcwd()), 'tools.db.on': True }, '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'static' } } config_session = models.connect() config = config_session.query(models.Config).first() if config is None: config = models.Config() config_session.add(config) config_session.commit() cherrypy.config.update({ 'server.socket_host': config.ip, 'server.socket_port': int(config.port), }) # config_session.remove() scan_refresh_scheduler.add_job(LinkRetrieve.handle_downloads, 'cron', hour='*/' + str(config.scan_interval), id='scan_job', misfire_grace_time=60) scan_refresh_scheduler.add_job(Utils.update_all, 'cron', day_of_week=config.refresh_day, hour=str(config.refresh_hour), id='refresh_job', misfire_grace_time=60) scan_refresh_scheduler.start() models.SAEnginePlugin(cherrypy.engine).subscribe() cherrypy.tools.db = models.SATool() cherrypy.tree.mount(Infringer(), '/', conf) cherrypy.engine.start() webbrowser.get().open( 'http://%s:%s' % (cherrypy.config['server.socket_host'], str(cherrypy.config['server.socket_port']))) cherrypy.engine.block()
def login_user(cls, email, username, firstName, lastName): """ Gets the user from the datastore, adds the user if not already there. We'll use the autoadd for now since that's how most SSO operations work. """ db = connect() try: #logging.info('Attempting to login with email: ' + email) result = db.query(_User).filter(_User.email == email).one() result.last_login = datetime.datetime.now() db.commit() db.close() return True except NoResultFound: logging.info('User not found, creating one!') db.add( _User(email=email, username=username, first_name=firstName, last_name=lastName, last_login=datetime.datetime.now())) db.commit() db.close() return True except MultipleResultsFound: logging.debug( 'Multiple accounts found for this email, this shouldn\' happen.... :-(' ) db.rollback() db.close() return False except: logging.debug( 'A different error occured than was expected.... What to do?') db.rollback() db.close() raise
def main(): engine, Session = models.connect() session = Session() add_albums = [] add_songs = [] with open('umphscraper/data.json', 'r') as f: read = f.read() data = json.loads(read) for album in data: if not album['tracks']: continue add_albums.append( models.Album( title=album['title'], lineage=album['lineage'], venue=album['venue'], transferred_by=album['transferred_by'], taped_by=album['taped_by'], date=(album['date'] or None), source=album['source'], archive_org_id=album['id'] ) ) for song in album['tracks']: add_songs.append( models.Song( title=song['title'], length=song['length'], filename=song['filename'], size=(song['size'] or 0), album_id=album['id'] ) ) session.add_all(add_albums + add_songs) session.commit() session.close()
def create(): # Controller de création d'un todo avec un PUT form = TodoForm(request.form) if request.method == 'PUT' and form.validate(): db_session = connect(True) newTodo = Todo() newTodo.title = form.title.data newTodo.done = False db_session.add(newTodo) db_session.commit() todo_data = { "id": newTodo.id, "title": newTodo.title, "done": newTodo.done } data = { "form": form, "todo_html": render_template( "todo.html", **todo_data ).replace("\n", "") } js_response = make_response( render_template("list.js", **data).replace("\n", "") ) js_response.headers["Content-Type"] = "text/javascript; charset=utf-8" return js_response return "", 400
def main(): engine, Session = models.connect() models.add_tables(models.Base, engine)
config_basic = config['BASIC'] AMQP_Host = config['AMQP']['AMQP_Host'] AMQP_Exchange = config['AMQP']['AMQP_Exchange'] AMQP_Exchange_Type = config['AMQP']['AMQP_Exchange_Type'] AMQP_Auth_Queue = config_auth['AMQP_Queue'] AMQP_Email_Queue = config['EMAIL']['AMQP_Queue'] AMQP_Profile_Queue = config['PROFILE']['AMQP_Queue'] Session_Duration = config_basic['Session_Duration'] JWT_Secret = config_basic['JWT_Secret'] # Connecting to PostgreSQL DB. while True: try: engine = connect() Base.metadata.bind = engine DBSession = sessionmaker(bind=engine) session = DBSession() break except Exception as err: print("[x] Auth Service PostgreSQL Not Ready Yet...") print('[x] Auth Service DB Connnection Established...') while True: try: # Connecting to Message Broker message_broker = pika.BlockingConnection( pika.ConnectionParameters(host=AMQP_Host)) break except Exception as err:
from flask import Flask, render_template, redirect, session, g from forms import SignupForm, LoginForm from models import db, connect, Users app = Flask(__name__) connect(app) app.config[ 'SECRET_KEY'] = '\xa6\x9f\xd7\x85X\xe9\x01\x12\x17\xa8\x1c\xdafL[\xadlL\x93Gc\xed\xd2w' app.config['SQLALCHEMY_DATABASE_URI'] = "postgres:///salesman" app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_ECHO'] = True db.create_all() CURR_USER_KEY = "current_user" @app.before_request def add_user_to_g(): """If we're logged in, add curr user to Flask global.""" if CURR_USER_KEY in session: g.user = Users.query.get(session[CURR_USER_KEY]) else: g.user = None def do_login(user): """Log in user.""" session[CURR_USER_KEY] = user.userID
def test_match_user_password_true(self): self.assertTrue( self.tester.match_user_password(models.connect(), "Fiona", self.account_password))
def test_match_user_password_false(self): self.assertFalse( self.tester.match_user_password(models.connect(), "Fiona", "wrong_password"))
#!/usr/bin/env python # -*- coding: utf-8 -*- from models import Partition, Node, DATABASE_PATH, create_tables, clear_tables, connect from shortcuts import ( degree, degree_distribution, diameter, eccentricity, clustering, average_clustering, transitivity, degree_centrality, closeness_centrality, betweenness_centrality ) from calculator import calculate, calculate_concurrent try: connect() except: # dies silently pass
import re import sys import falcon import json import logging from peewee import IntegrityError from playhouse.shortcuts import model_to_dict from wsgiref import simple_server from models import Todo, SnoozeAll, TodoList import models DEFAULT_LIST = 'Reminders' count = 0 models.connect() def get_module_logger(mod_name): """ To use this, do logger = get_module_logger(__name__) """ logger = logging.getLogger(mod_name) handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s [%(name)-12s] %(levelname)-8s %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) logger.setLevel(logging.DEBUG) return logger
rowDict[column.name] = str(getattr(row, column.name)) for key in realData: if not isinstance(realData[key], list): self.assertEqual(str(realData[key]), rowDict[key]) def test_series_3(self): realData = series[2] assert len(realData) == 16 series_table = get_series_table(meta, con) select_clause = series_table.select(series_table.c.id == realData["id"]) rows = select_clause.execute() row = rows.fetchone() rowDict = {} for column in series_table.columns: rowDict[column.name] = str(getattr(row, column.name)) for key in realData: if not isinstance(realData[key], list): self.assertEqual(str(realData[key]), rowDict[key]) # ---- # main # ---- if __name__ == '__main__': con, meta = connect("charlesgong", "Charles") main()
mail_content = unicode(quopri.decodestring(mail.headers + "\r\n" + mail.body), 'utf-8', errors='ignore') return render_template('show_mail.html', **locals()) @app.route("/<user>@<domain>/<int:mail_id>/delete/") @app.route("/<user>/<int:mail_id>/delete/") def delete_mail(user, mail_id, domain=settings.MY_DOMAINS[0]): try: mail = list( Mail.select( AND( Mail.q.user == User.select( AND(User.q.name == user, Domain.q.name == domain))[0], Mail.q.id == mail_id)))[0] except IndexError: abort(404) #if divmod((datetime.datetime.now() - mail.ts).total_seconds(), 60)[0] > 10: if (datetime.datetime.now() - mail.ts) > datetime.timedelta(seconds=600): abort(403) Mail.delete(mail_id) return redirect(url_for('list_mail', user=user, domain=domain)) if __name__ == "__main__": connect() app.debug = settings.DEBUG app.run()
def connect(db=DATABASE_URI): global connected if not connected: models.connect(db) connected = True
data = editor.get_data() project = models.Project.create(data) project.save() self.projects.load_all() self.projects.setCurrentIndex(self.projects.findText(project.name)) return True else: return False def on_update_project(self): self.projects.load_all() def on_build_tree(self): project = self.projects.current_obj() project.build_tree() def change_project(self): project = self.projects.current_obj() if project: self.shot_manager.set_project(project) if __name__ == "__main__": models.connect() app = QtGui.QApplication(sys.argv) tvm_manager = TVManager() tvm_manager.resize(1024, 800) tvm_manager.show() sys.exit(app.exec_())
def connectDB(dbs): #connect to the database via models print('setting up DB...') models.connect(dbs) return
""" Saves categories scraped into db """ with open("./data/data.tsv", 'r') as category_reader: category_reader = csv.reader(category_reader, delimiter='\t') for line in category_reader: line[1] = line[1].replace('[', "").replace(']',"") organizations, authors, titles, start_date, duration = line category = models.Category() category.organization = organizations category.author = authors category.title = titles category.start_date = start_date category.duration = duration try: session.add(category) session.commit() except: session.rollback() raise finally: session.close() #return category def main(session): process_item_to_db(session) if __name__ == '__main__': session = models.connect() main(session)
import time import itertools import models import os from models import User from models.user import UserPreferenceModel from learning.algorithm import DummyAlgorithm, AlgorithmLibrary, KeywordAlgorithm from learning.processing import ProducerThread, ConsumerThread, SingleProducerProcess models.connect(os.environ.get('DATABASE_URI')) class UserCoordinator(ProducerThread): def work(self): for user in User.select(): if self.produce(user.id): self._logger.info('Producing user %s.' % user.id) time.sleep(10) class ScoringWorker(ConsumerThread): def __init__(self, worker_id, task_queue, completed_queue): ConsumerThread.__init__(self, worker_id, task_queue, completed_queue) self._library = AlgorithmLibrary([DummyAlgorithm(), KeywordAlgorithm()]) def consume(self, user_id): user = User.get(id=user_id) self._logger.info('Consuming user %s.', user.id) articles = list(user.all_articles())
from models import connect, load_schema, Person, Pet connect(':memory:') load_schema('ex45.sql') def test_create(): p = Person('Emil', 'Raubach', 46) p.create() p.read()