def modify_org(args): connect_db(get_database_url()) try: with session_scope() as session: try: org = session.query(Organisation).filter_by( name=args.name).one() is_new = True except sqlalchemy.orm.exc.NoResultFound: is_new = False org = Organisation(name=args.name) session.add(org) if args.region is not None: org.region = args.region if args.url is not None: org.url = args.url if args.customers is not None: org.number_of_customers = args.customers session.flush() session.expunge(org) except sqlalchemy.exc.IntegrityError as e: print('Failed to create organisation %s' % args.name) print('\n'.join(e.orig.args)) sys.exit(1) if is_new: print('Added organisation %s' % org.name) else: print('Updated organisation %s' % org.name) print('ID: %s' % org.id)
def __init__(self, params): self.params = params # load configuration model.load_config(params.config, basepath=params.path) # connect to database model.connect_db() # clear db model.ue.UE.drop_collection() model.location.Location.drop_collection() model.accesspoint.AccessPoint.drop_collection() # setup zero mq receiver self.setup_zmq() # load access point definitions from configuration file # and from remote AP manager component. # Deletes all current AP definitions at first. # If connection to remote AP manage API is not possible, # the system will run without any AP object and thus # no APs are assigned to UEs. model.accesspoint.AccessPoint.refresh( model.CONFIG["accesspoints"], ap_manager_client.get_accesspoints()) # load management algorithm plugin.load_algorithms( model.CONFIG["algorithm"]["available"], model.CONFIG["algorithm"]["default"]) # kick of AP state fetcher thread self.apFetcherThread = updater.AccessPointStateFetcher() self.apFetcherThread.start() # enable "always_on_macs" on all access points if "always_on_macs" in model.CONFIG: for mac in model.CONFIG["always_on_macs"].itervalues(): ap_manager_client.set_mac_list( mac, [ap.uuid for ap in model.accesspoint.AccessPoint.objects], []) logging.info("Enabled MAC %s on all APs." % str(mac))
def setUp(self): # This runs before each of the tests in this class. # Requires you to set up testing client self.client = app.test_client() app.config['TESTING'] = True connect_db(app)
def __init__(self, params): self.params = params # load configuration model.load_config(params.config, basepath=params.path) # connect to database model.connect_db() # setup zero mq sender api.setup_zmq()
def modify_user(args): connect_db(get_database_url()) password = getpass.getpass(prompt='Enter new password: '******'Re-enter password: '******'Failed to add user %s' % args.name) print('Passwords do not match') sys.exit(1) try: with session_scope() as session: if args.organisation is not None: organisation = session.query(Organisation) \ .filter_by(name=args.organisation).one() else: organisation = None try: user = session.query(AppUser).filter_by(email=args.email).one() is_new = False if password != "": user.password = password except sqlalchemy.orm.exc.NoResultFound: is_new = True user = AppUser(email=args.email) session.add(user) if password != "": user.password = password else: print( "Not setting a password. User will not be able to log in." ) user.password = "******" if args.name is not None: user.name = args.name if args.role is not None: user.role = args.role if organisation is not None: user.organisation_id = str(organisation.id) session.flush() session.expunge(user) except sqlalchemy.exc.IntegrityError as e: print('Failed to add user %s' % args.email) print('\n'.join(e.orig.args)) sys.exit(1) if is_new: print('Added user %s' % user.email) else: print('Updated user %s' % user.email) print('ID: %s' % user.id)
def connect_db(): global SessionStaging, SessionUpstream engine_source = model.connect_db( 'postgresql://*****:*****@%s:5432/postgres' % os.environ['SOURCE']) engine_target = model.connect_db( 'postgresql://*****:*****@%s:5432/postgres' % os.environ['TARGET']) SessionStaging = sessionmaker(bind=engine_source) SessionUpstream = sessionmaker(bind=engine_target)
def populate_items(item_list, level): db = model.connect_db() successfully_entered = 0.0 no_file_error = 0.0 for item_id, item_seo_title in item_list: try: model.enter_new_item(db, item_id, level) print item_id successfully_entered += 1 except: print "++++++++++++++++++++++++++" print "couldn't find file" print item_id print item_seo_title print "++++++++++++++++++++++++++" no_file_error += 1 print "Successfully entered: " + str(successfully_entered) print "Errors: " + str(no_file_error) print "Error rate: " + str(round(no_file_error / successfully_entered * 100, 2)) + "%" db.close()
def new_user(): user_name= request.form['user_name'] email= request.form['user_email'] db = model.connect_db() #new_user(db, email, password, name) user_id = model.new_user(db, email, None, user_name) return redirect("/new_task")
def sets_per_item(): db = model.connect_db() query = """SELECT COUNT(set_id) from Items_Sets GROUP BY item_id""" result = db.execute(query) result_list = [ row[0] for row in result.fetchall() ] # Create a histogram histogram = [0] * 23 print histogram for num in result_list: if num <= 22: histogram[num] += 1 elif num > 22: histogram[22] += 1 print histogram # Print out the histogram for bucket in range(1, len(histogram)): if bucket <= 21: print "%d items <-----> belong to %d sets" % (histogram[bucket], bucket) elif bucket == 22: print "%d items <-----> belong to 22 or more sets" % histogram[bucket] # Check against total # of Items_Sets records by doing SumProduct sum_p = 0 for bucket in range(1, len(histogram)): sum_p += bucket * histogram[bucket] print sum_p db.close()
def save_task(): task_title = request.form['task_title'] user_id = request.form['user_id'] db = model.connect_db() # assume all tasks are attached to user 1 :( task_id = model.new_task(db, task_title, user_id) return redirect("/tasks")
def save_task(): title = request.form['title'] db = model.connect_db() #Assume that all tasks are attached to user Christian Fernandez #task ID below task_id = model.new_task(db, title, 'Christian', 'Fernandez') return redirect("/tasks")
def populate_sets_fans(batch): db = model.connect_db() for set_id, seo_title in batch: model.enter_new_sets_fans(db, set_id)
def list_of_unique_items(batch): # Make a tuple of the relevant sets to pass into the query relevant_sets = tuple([ b[0] for b in batch ]) question_marks = ["?"] * len(relevant_sets) question_marks_string = ", ".join(question_marks) # Connecting to database db = model.connect_db() # Format and execute the SQL query query_template = """SELECT * FROM Sets_Items WHERE set_id IN (%s)""" query = query_template % (question_marks_string) result = db.execute(query, relevant_sets) # Get a list of records, where each item is a fan name list_of_item_ids = [] list_of_item_seo_titles = [] for row in result.fetchall(): if not row[2] in list_of_item_ids: # Check for duplicates # We need to delay zipping until the end b/c of this. list_of_item_ids.append(row[2]) list_of_item_seo_titles.append(row[3]) list_of_items = zip(list_of_item_ids, list_of_item_seo_titles) return list_of_items
def list_of_unique_fans(batch): # Make a tuple of the relevant sets to pass into the query relevant_sets = tuple([ b[0] for b in batch ]) question_marks = ["?"] * len(relevant_sets) question_marks_string = ", ".join(question_marks) # Connecting to database db = model.connect_db() # Format and execute the SQL query query_template = """SELECT * FROM Sets_Fans WHERE set_id IN (%s)""" query = query_template % (question_marks_string) result = db.execute(query, relevant_sets) # Get a list of records, where each item is a fan name list_of_fans = [] for row in result.fetchall(): if not row[3] in list_of_fans: # Check for duplicates if not row[2] == "0": # If fan_id is 0, means they don't have an actual account list_of_fans.append(row[3]) return list_of_fans
def print_overlap(): db = model.connect_db() # Creates a table with 2 columns -- (a) fan_name (b) num out of 5 sets in batch_1 that they fanned cursor = db.execute("SELECT fan_name, COUNT(fan_name) FROM Sets_Fans GROUP BY fan_name") # Doing the rest in Python instead of SQL for now --> need to look up how to query the result of a query total_fans = 0.0 sets_rated_by_each_fan = ["Not Applicable", 0.0, 0.0, 0.0, 0.0, 0.0] for row in cursor.fetchall(): number_rated = row[1] sets_rated_by_each_fan[number_rated] += 1 total_fans += 1 # Transform frequency counts into percentages print "LEVEL OF OVERLAP" print "Out of " + str(int(total_fans)) + " total fans who rated 5 'Popular' sets" print "--------------------------------------------------" for x in range(1,6): percentage = int(round(sets_rated_by_each_fan[x]/total_fans*100)) print str(int(sets_rated_by_each_fan[x])) + " out of " + str(int(total_fans)) + " -- (" + str(percentage) + "%) -- rated " + str(x) + " out of 5 sets" db.close()
def winners(): db = model.connect_db() participants_from_db = model.get_participants(db) games_from_db = model.get_games(db) print participants_from_db entries = [] for item in participants_from_db: entry = item['number_entries'] person = item['participant_name'] for i in range(entry): entries.append(person) random.shuffle(entries) games_list = [] for game in games_from_db: games_list.append(game["game"]) random.shuffle(games_list) decisions = {} a = 0 while a < len(entries): if entries[a] in decisions: decisions[entries[a]].append(games_list[a]) else: decisions[entries[a]] = [games_list[a]] a +=1 print decisions return render_template("winners.html", winners = decisions)
def save_participant(): participant_name = request.form['participant_name'] number_entries = request.form['number_entries'] db = model.connect_db() participant_id = model.new_participant(db, participant_name, number_entries) print participant_id return redirect("/the_lottery")
def get_session(): # session is stored in application global if not hasattr(g, 'session'): engine = model.connect_db() Session = sessionmaker(bind=engine) g.session = Session() return g.session
def login(): email = request.form['email'] password = request.form['password'] db = model.connect_db() auth_user = model.authenticate(db, email, password) if auth_user != None: return redirect("/Tasks")
def connect_db(): db_url = model.get_database_url() model.connect_db(db_url) try: model.connect_db_ro(db_url) except model.MissingUser: # This shouldn't happen because the user is created as part of the # schema. However if the user is accidentally deleted - or if the # database is restored from backup before the app is started for the # first time - then this is the easiest way to get the user back. model.create_analyst_user() model.connect_db_ro(db_url) except model.WrongPassword: # If the database is restored from a backup, the analyst password might # be wrong. model.reset_analyst_password() model.connect_db_ro(db_url)
def authenticate(): db = model.connect_db() email = request.form['email'] password = request.form['password'] user_info = model.authenticate(db, email, password) if user_info == None: return redirect('/') else: return redirect('/tasks')
def list_tasks(): db = model.connect_db() tasks_from_db = model.get_tasks(db, None) completed_items = request.form.getlist("completed_t_f", type=int) if completed_items: for task in completed_items: model.complete_task(db, task) return render_template("tasks.html", tasks_field = tasks_from_db)
def list_tasks(): db = model.connect_db() tasks_from_db = model.get_tasks(db, None) user_id_list = [] for dictionary in tasks_from_db: user_id_list.append(dictionary["user_id"]) for user_id in user_id_list: users_from_db = model.get_user(db, user_id) return render_template("list_tasks.html", tasks=tasks_from_db,users=users_from_db)
def list_tasks(): db = model.connect_db() tasks_from_db = model.get_tasks(db, None) completed_items = request.form.getlist("completed_t_f", type=int) if completed_items: for task in completed_items: model.complete_task(db, task) return render_template("tasks.html", tasks_field=tasks_from_db)
def populate_items_sets(list_of_ids): db = model.connect_db() for item_id in list_of_ids: model.enter_new_items_sets(db, item_id) db.close()
def unique_records_twocol(table, col1, col2, level): # Format and execute the SQL query db = model.connect_db() query_template = """SELECT DISTINCT (%s), (%s) FROM (%s) WHERE level = (%d)""" query = query_template % (col1, col2, table, level) result = db.execute(query) # Get a list of records and return it list_of_items = [ row for row in result.fetchall() ] db.close() return list_of_items
def get_list_1(): list_of_tups = [] db = model.connect_db() query = """SELECT DISTINCT set_id, set_seo_title, set_imgurl FROM Items_Sets""" result = db.execute(query) result_list = [ row for row in result.fetchall() ] db.close() return result_list
def list_of_unique_sets(level): """ Return a list of unique sets as (set_id, set_seo_title) which will be passed to create_file function """ # Format and execute the SQL query db = model.connect_db() query = """SELECT DISTINCT set_id, set_seo_title FROM Items_Sets WHERE level = ?""" result = db.execute(query, (level,)) # Get a list of records and return it list_of_sets = [ row for row in result.fetchall() ] db.close() return list_of_sets
def save_task(): # print request.form task_title = request.form['task_title'] category = request.form["category"] priority = request.form["priority"] due_date = request.form["due_date"] #due_date = datetime.datetime.now() db = model.connect_db() created_at = datetime.datetime.now() task_id = model.new_task(db, task_title, 1, created_at, 0, category, None, priority, due_date) # return "Success!" return redirect("/tasks")
def get_good_items(): db = model.connect_db() query = """SELECT item_id, seo_title FROM Items WHERE usd_price > 0""" result = db.execute(query) result_list = [ row for row in result.fetchall() ] result_urls = [] for tup in result_list: url = polyvore.get_item_url(tup[0], tup[1]) result_urls.append(url) db.close() return result_urls
def whatever2(): db = model.connect_db() for set_id, set_seo_title in batch_1: try: model.enter_new_set(db, set_id, 1) except IOError: print "No file exists (likely Unicode Error)" for set_id, set_seo_title in level_3: try: model.enter_new_set(db, set_id, 3) except IOError: print "No file exists (likely Unicode Error)" db.close()
def enter_list_1(): list_to_enter = get_list_1() db = model.connect_db() c = db.cursor() query = """INSERT INTO Sets VALUES(NULL, ?, ?, NULL, NULL, NULL, NULL, NULL, NULL, ?, NULL, NULL, NULL, NULL, NULL, 4)""" counter = 0 for tup in list_to_enter: # print tup[0] c.execute(query, (tup[0], tup[1], tup[2])) print counter counter += 1 db.commit() db.close()
def list_of_unique_items(batch): """ Return a list of unique items as (item_id, item_seo_title) which will be passed to create_file function """ # Make a tuple of the relevant sets to pass into the query relevant_sets = tuple([ b[0] for b in batch ]) question_marks = ["?"] * len(relevant_sets) question_marks_string = ", ".join(question_marks) # Format and execute the SQL query db = model.connect_db() query_template = """SELECT DISTINCT item_id, item_seo_title FROM Sets_Items WHERE set_id IN (%s)""" query = query_template % (question_marks_string) result = db.execute(query, relevant_sets) # Get a list of records and return it list_of_items = [ row for row in result.fetchall() ] db.close() return list_of_items
def show_setup(): db = model.connect_db() participants_from_db = model.get_participants(db) games_from_db = model.get_games(db) participant_list = [] number_entry_list = [] for participant in participants_from_db: participant_list.append(participant["participant_name"]) number_entry_list.append(participant["number_entries"]) participants = zip(participant_list, number_entry_list) games_list = [] for game in games_from_db: games_list.append(game["game"]) return render_template("show_setup.html", participants=participants, games=games_list)
def grab_these_relationships(): db = model.connect_db() query1 = """SELECT DISTINCT user_id FROM Users WHERE level = 2.1""" query2 = """SELECT DISTINCT user_id FROM Users WHERE level = 2.2""" query3 = """SELECT DISTINCT user_id FROM Users WHERE level = 2.3""" query4 = """SELECT DISTINCT user_id FROM Users WHERE level = 2.4""" result1 = db.execute(query1) result2 = db.execute(query2) result3 = db.execute(query3) result4 = db.execute(query4) list_fans_1 = [ row[0] for row in result1.fetchall() ] list_fans_2 = [ row[0] for row in result2.fetchall() ] list_fans_3 = [ row[0] for row in result3.fetchall() ] list_fans_4 = [ row[0] for row in result4.fetchall() ] db.close()
def whatever(): db = model.connect_db() for i in range(0, 300): print list_of_fan_names[i] model.enter_new_user(db, list_of_fan_names[i], 2.1) for i in range(300, 600): print list_of_fan_names[i] model.enter_new_user(db, list_of_fan_names[i], 2.2) for i in range(600, 900): print list_of_fan_names[i] model.enter_new_user(db, list_of_fan_names[i], 2.3) for i in range(900, len(list_of_fan_names)): print list_of_fan_names[i] model.enter_new_user(db, list_of_fan_names[i], 2.4) db.close()
import model import telegram from sqlalchemy.orm import sessionmaker engine = model.connect_db() Session = sessionmaker(bind=engine) session = Session() def analyse_activity(owner_id, activity_id): athlete = session.query(model.Athlete).get(owner_id) telegram.newActivity(athlete.firstname, athlete.lastname, activity_id)
def set_up_db(): g.db = model.connect_db()
import model import datetime db = model.connect_db() user_id = model.new_user(db, "*****@*****.**", "securepassword", "Christian") task = model.new_task(db, "A task for Christian", user_id, datetime.datetime.now(), None, "category3", None, 4, "Tuesday") task = model.new_task(db, "The best task OH MY FREAKING GOD", user_id, datetime.datetime.now(), None, "category3", None, 5, "Next year") user_id = model.new_user(db, "*****@*****.**", "awesomepassword", "Gulnara") task = model.new_task(db, "let's drink", user_id, datetime.datetime.now(), None, "category3", None, 1, "in an hour") task = model.new_task(db, "go to sleep", user_id, datetime.datetime.now(), None, "category4", None, 2, "in 2 hours") user_id = model.new_user(db, "*****@*****.**", "yeahyeahyeah", "Lindsay") task = model.new_task(db, "go hiking", user_id, datetime.datetime.now(), None, "category78", None, 3, "sunday") task = model.new_task(db, "read a few books", user_id, datetime.datetime.now(), None, "category54", None, 4, "this weekend")
def connect_db(): url = model.get_database_url() model.connect_db(url)
from flask import Flask, render_template, redirect, request from model import db, connect_db, Pet from forms import PetForm app = Flask(__name__) app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost/adoptpets_db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_ECHO'] = True app.config['SECRET_KEY'] = 'adoptpets' connect_db(app) db.create_all() @app.route('/') def home_page(): pet_all = Pet.query.all() return render_template("home.html", pets=pet_all) @app.route('/add', methods=['GET', 'POST']) def add_pets(): form = PetForm() if form.validate_on_submit(): new = Pet(name=form.name.data, species=form.species.data, photo_url=form.photo_url.data, age=form.age.data, notes=form.notes.data) db.session.add(new)
if not getattr(ride, attr): setattr(ride, attr, None) return ride if __name__ == '__main__': # Debug for DebugToolbarExtension. Also so server restarts when changes made # app.debug = True # # Connection function from model.py # connect_db(app) # # Debug Toolbar # DebugToolbarExtension(app) # # Allows redirects # app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False # app.run(host="0.0.0.0", port=5000) # app.run(debug=True, host="0.0.0.0") connect_db(app, os.environ.get("DATABASE_URL")) db.create_all(app=app) DEBUG = "NO_DEBUG" not in os.environ PORT = int(os.environ.get("PORT", 5000)) app.run(host="0.0.0.0", port=PORT, debug=DEBUG)
def before_request(): g.db = model.connect_db()
def set_up_db(): g.db = model.connect_db() # global variable, db
def setUpClass(cls): url = model.get_database_url() cls._engine = model.connect_db(url) cls.destroy_schema() model.drop_analyst_user() model.Base.metadata.create_all(cls._engine)