def __init__(self, erd_handle, cfs_handle = '', options = {}, app_name = "local", number_to_recommend = 50): self.training_problems = {} self.options = {} self.options['tag_based'] = 0 self.options['normalize'] = 0 self.options['sample_data'] = 1 self.options['penalize'] = 1 if 'tag_based' in options: self.options['tag_based'] = options['tag_based'] if 'normalize' in options: self.options['normalize'] = options['normalize'] if 'sample_data' in options: self.options['sample_data'] = options['sample_data'] if 'penalize' in options: self.options['penalize'] = options['penalize'] self.conn=db.connect() self.cursor = self.conn.cursor() self.remote_conn = db.connect('remote') self.remote_cursor = self.remote_conn.cursor() self.cfs_url = "http://codeforces.com/api/user.info" self.erd_url = "http://erdos.sdslabs.co/users/" self.cfs_handle = 'cfs' + str(cfs_handle) self.erd_handle = 'erd' + str(erd_handle) self.number_to_recommend = number_to_recommend self.uid = self.get_uid() # print self.uid self.calculate_difficulty()
def db(request): _db.connect("sqlite://", init=True) def close(): _db.disconnect() request.addfinalizer(close) return _db
def admin_institutions_remove(self, id): userid = cherrypy.session.get(auth.SESSION_USERID) requireAdmin(userid) if request.method == 'POST': cnx, status = db.connect() cursor = cnx.cursor() query = "DELETE FROM institution WHERE institutionid=%s" cursor.execute(query, (id,)) query = "DELETE FROM course where institutionid = %s" cursor.execute(query, (id,)) cursor.close() cnx.close() return templating.render("redirect.html", STATUS="alert-success", MESSAGE="Institution deleted...") else: cnx, status = db.connect() cursor = cnx.cursor() query = "SELECT institution_name FROM institution WHERE institutionid=%s" cursor.execute(query, (id,)) name = cursor.fetchone()[0] cursor.close() cnx.close() return templating.render("confirm.html", TITLE="Are you sure you want to delete "+name+"?", MESSAGE="The institution and all it's courses will be permanently removed.", CONFIRM_LABLE="DELETE")
def admin_institutions(self, institution="", *args, **kwargs): """ Lists available institutions. >>> authorizeTests() >>> self = Admin() >>> ret = self.admin_institutions() >>> ('Victoria University of Wellington', 2) in ret.OPTION True >>> ret = self.admin_institutions(2) >>> ret.INSTITUTION_ID, ret.INSTITUTION, ret.CONTACT, ret.WEBSITE, ret.DESCRIPTION (2, 'Victoria University of Wellington', None, None, None) """ userid = cherrypy.session.get(auth.SESSION_USERID) requireAdmin(userid) allow(["HEAD", "GET", "POST"]) redirect = "NO" options = [] if institution: cnx, status = db.connect() cursor = cnx.cursor() query = ("SELECT institution_name, institutionid from institution order by institution_name") cursor.execute(query) options = list(cursor) cursor.close() cnx.close() displayInstitution = "" displayContact = "" displayWebsite = "" displayDescription = "" if institution == "": cnx, status = db.connect() cursor = cnx.cursor() query = ("SELECT institution_name, institutionid from institution order by institution_name") cursor.execute(query) institution = "" for (institute) in cursor: options.append(institute) if institution == "": institution = institute[1] cursor.close() cnx.close() cnx, status = db.connect() cursor = cnx.cursor() query = ( "SELECT institution_name,description,contact,website from institution where institutionid = '" + str(institution) + "'") cursor.execute(query) displayInstitution, displayDescription, displayContact, displayWebsite = cursor.fetchone() cursor.close() cnx.close() return templating.render("admin_institutions.html", ROOT_URL=config.VIRTUAL_URL, ERROR="", REDIRECT=redirect, OPTION=options, INSTITUTION_ID=institution, INSTITUTION=displayInstitution, CONTACT=displayContact, WEBSITE=displayWebsite, DESCRIPTION=displayDescription, IS_ADMIN=isAdmin(userid))
def admin_course_remove(self, id): userid = cherrypy.session.get(auth.SESSION_USERID) requireAdmin(userid) if request.method == 'POST': cnx, status = db.connect() cursor = cnx.cursor() query = "DELETE FROM course WHERE courseid=%s" cursor.execute(query, (id,)) cursor.close() cnx.close() return templating.render("redirect.html", STATUS="alert-success", MESSAGE="Course deleted...") else: cnx, status = db.connect() cursor = cnx.cursor() query = """SELECT course.course_name, institution.institution_name FROM course, institution WHERE course.courseid=%s AND institution.institutionid = course.institutionid""" cursor.execute(query, (id,)) course, institution = cursor.fetchone() cursor.close() cnx.close() return templating.render("confirm.html", TITLE="Are you sure you want to delete %s at %s?" % (course, institution), MESSAGE="This course will be permanently removed.", CONFIRM_LABLE="DELETE")
def admin_teacher_revoke(self, id): userid = cherrypy.session.get(auth.SESSION_USERID) requireAdmin(userid) if request.method == 'POST': cnx, status = db.connect() cursor = cnx.cursor() query = "DELETE FROM teacher_info WHERE userid=%s" cursor.execute(query, (id,)) cursor.close() cnx.close() return templating.render("redirect.html", STATUS="alert-success", MESSAGE="Admin rights revoked...") else: cnx, status = db.connect() cursor = cnx.cursor() query = "SELECT username FROM whiley_user WHERE userid=%s" cursor.execute(query, (id,)) name = cursor.fetchone()[0] cursor.close() cnx.close() return templating.render("confirm.html", TITLE="Are you sure you want to revoke %s's teaching rights?" % name, MESSAGE="", CONFIRM_LABLE="REVOKE")
def main(): import app import db import handlers application = app.app(handlers.URLS) settings.APP_SETTINGS['debug'] = True settings.APP_SETTINGS['static_path'] = os.path.join('/home/philip/Development/repo1/server', "static"), db.connect( 'repo1', host='localhost', port=27017 ) #insert default data if 1==2: # code = db.QR(url='testing') # code.save() bar = db.Bar(name="Freds bar") bar.save() server = tornado.httpserver.HTTPServer(application) server.listen(80) tornado.ioloop.IOLoop.instance().start()
def main(): logger = logging.getLogger('poke-receiver') logger.addHandler(logging.FileHandler(settings.LOGFILE_RECEIVER)) logger.setLevel(logging.INFO) logger.info("receiver.py started") conn = db.connect(settings.DATABASE) run = True i = timestamp() while run: i += 1 try: data = pickle.load(sys.stdin) except EOFError: run = False except pickle.UnpicklingError: logger.error("couldn't unpickle sys.stdin, ignoring...") else: db.store(conn, data, i) logger.info("data stored: %s %s" % (i, data)) if i % settings.DB_COMPRESSION_INTERVAL == 0: db.compress(conn, i) conn.close() try: time.sleep(settings.DB_COMPRESSION_SLEEP) except KeyboardInterrupt: run = False else: conn = db.connect(settings.DATABASE) logger.info("db compressed, reconnected") conn.close()
def connectDB(): config = None with open(HPCConfig.importingConfigPath, 'rb') as f: config = json.load(f) db.connect(config) return db
def user_courses(self, studentinfoid=None, institution="", validationcode="", courseid="", *args, **kwargs): """Assign user to select course """ if studentinfoid is None: raise cherrypy.HTTPRedirect("/") allow(["HEAD", "GET", "POST"]) error = False error_msg = " " redirect = "NO" options = [] course_list = [] if institution: cnx, status = db.connect() cursor = cnx.cursor() query = ("SELECT institutionid,institution_name from institution order by institution_name") cursor.execute(query) options = list(cursor) cursor.close() if courseid: cnx, status = db.connect() cursor = cnx.cursor() error = insertuserdetails(studentinfoid, institution, courseid, validationcode) cursor.close() if error is False: message="User Created, Welcome! Redirecting..." template = lookup.get_template("redirect.html") return template.render(STATUS="alert-success", MESSAGE=message) else: error_msg= "Wrong Validation Code" if institution == "": cnx, status = db.connect() cursor = cnx.cursor() query = ("SELECT institutionid,institution_name from institution order by institution_name") cursor.execute(query) for (institutionid,institution_name) in cursor: options.append((institutionid, institution_name)) if institution == "": institution = str(institutionid) cursor.close() ##get courses list cnx, status = db.connect() cursor = cnx.cursor() query = ("SELECT courseid,code from course where institutionid = '" + institution + "' order by code") cursor.execute(query) course_list = list(cursor) cursor.close() return templating.render("user_institutions.html", ERROR=error, ERRORMSG=error_msg, NOTALLOWED=False, ROOT_URL=config.VIRTUAL_URL, OPTION=options, COURSE_LIST=course_list, STUDENTINFOID=studentinfoid, INSTITUTION=institution)
def make(filename): db.connect() db.make() if filename: process_file(filename) else: import_groups() #import_data_gov_in.start() #import_devinfo.start() import_worldbank_data.start()
def test_db_connect(self): dbFileName = 'xxxx.txt' with self.assertRaises(db.DBFileNameError): conn, cursor = db.connect(dbFileName) dbFileName = 'unittest_%d.db' % time.time() conn, cursor = db.connect(dbFileName) self.assertTrue(dbFileName in os.listdir('.')) self.assertTrue(isinstance(conn, sqlite3.Connection)) self.assertTrue(isinstance(cursor, sqlite3.Cursor))
def admin_courses(self, institution="", *args, **kwargs): """ Lists all available courses. >>> authorizeTests() >>> self = Admin() >>> ret = self.admin_courses() >>> (2, 'Victoria University of Wellington') in ret.OPTION True >>> ret = self.admin_courses('2') >>> (2, 'Victoria University of Wellington') in ret.OPTION True >>> ret.INSTITUTION '2' >>> (1, 'SWEN302') in ret.COURSE_LIST True """ userid = cherrypy.session.get(auth.SESSION_USERID) requireAdmin(userid) allow(["HEAD", "GET", "POST"]) error = "" redirect = "NO" options = [] course_list = [] if institution: cnx, status = db.connect() cursor = cnx.cursor() query = ("SELECT institutionid,institution_name from institution order by institution_name") cursor.execute(query) options = list(cursor) cursor.close() else: cnx, status = db.connect() cursor = cnx.cursor() query = ("SELECT institutionid,institution_name from institution order by institution_name") cursor.execute(query) for (institutionid,institution_name) in cursor: options.append((institutionid, institution_name)) if institution == "": institution = str(institutionid) cursor.close() cnx, status = db.connect() cursor = cnx.cursor() query = ("SELECT courseid,code from course where institutionid = '" + institution + "' order by code") cursor.execute(query) course_list = list(cursor) cursor.close() return templating.render("admin_courses.html", ROOT_URL=config.VIRTUAL_URL, ERROR=error, REDIRECT=redirect, OPTION=options, INSTITUTION=institution, COURSE_LIST=course_list, IS_ADMIN=isAdmin(userid))
def main(): db.connect() if db.roadhouse is None: print('FATAL: Cannot connect to the database!') return tornado.options.parse_command_line() app = Application() app.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def newfunc(): web._context[threading.currentThread()] = tmpctx # Create new db cursor if there is one else background thread # overwrites foreground cursor causing rubbish data into dbase if web.config.get('db_parameters'): import db db.connect(**web.config.db_parameters) func(*a, **kw) myctx = web._context[threading.currentThread()] for k in myctx.keys(): if k not in ['status', 'headers', 'output']: try: del myctx[k] except KeyError: pass
def check_con_params(): if con_params: try: connect() except Exception: print('''Error with connection to database. \ \nCheck connection parameters in file db.py''') return False else: return True else: print('Lack of connection parameters in file db.py') return False
def setup(): """Call once to set everything up:""" db.connect(db_config) #Map all the model objects to the column families: for cf in db_config["column_families"]: try: model_obj = globals()[cf] if model_obj.__base__ != ModelBase: continue cass_cf = getattr(db,cf) except KeyError: continue model_obj.objects = pycassa.ColumnFamilyMap(model_obj, cass_cf)
def load(): """ Loads a new context for the thread. You can ask for a function to be run at loadtime by adding it to the dictionary `loadhooks`. """ _context[threading.currentThread()] = storage() ctx.status = '200 OK' ctx.headers = [] if config.get('db_parameters'): import db db.connect(**config.db_parameters) for x in loadhooks.values(): x()
def save(project_name, filename, data): userid = cherrypy.session.get(auth.SESSION_USERID) cnx, status = db.connect() cursor = cnx.cursor() print "saving Project:", project_name, userid sql = "SELECT p.projectid FROM project p where p.userid = %s AND p.project_name = %s" cursor.execute(sql, (userid,project_name)) project = cursor.fetchone() if project: projectid = project[0] else: sql = "INSERT INTO project (project_name, userid) VALUES (%s, %s)" cursor.execute(sql, (project_name, userid)) projectid = cursor.lastrowid sql = "INSERT INTO file (projectid, filename, source) VALUES (%s, %s, %s)" print projectid, filename, data print sql cursor = cnx.cursor() cursor.execute(sql, (projectid, filename, data)) if cursor.fetchwarnings(): for item in cursor.fetchwarnings(): print item cursor.close() cursor = cnx.cursor() cursor.execute("select * from file where projectid = %s", (projectid, )) print cursor.fetchall()
def change_porder(cid,porder): conn=connect() cursor=conn.cursor() cursor.execute("update card set porder=%s where cid=%s",[porder,cid]) conn.commit() cursor.close() conn.close()
def change_fid(cid,fid): conn=connect() cursor=conn.cursor() cursor.execute("update card set fid=%s where cid=%s",[fid,cid]) conn.commit() cursor.close() conn.close()
def change_main(cid,main): conn=connect() cursor=conn.cursor() cursor.execute("update card set main=%s where cid=%s",[main,cid]) conn.commit() cursor.close() conn.close()
def del_one_card(cid): conn=connect() cursor=conn.cursor() cursor.execute("delete from card where cid=%s",[cid]) conn.commit() cursor.close() conn.close()
def export_to_database(self): connection = db.connect() c = connection.cursor() c.execute("SELECT id FROM indicators WHERE name = 'Population'") population_id = c.fetchone()[0] c.execute("SELECT id FROM indicators WHERE name = 'Dwellings'") dwellings_id = c.fetchone()[0] c.execute("SELECT id FROM indicators WHERE name = 'Occupied dwellings'") occupied_dwellings_id = c.fetchone()[0] c.execute('DELETE FROM indicator_region_values WHERE indicator_id IN %s', ((population_id, dwellings_id, occupied_dwellings_id),)) c.execute(""" PREPARE insert_region_values (INT, INT, INT, INT, CHAR) AS INSERT INTO indicator_region_values (region_id, indicator_id, value_integer, note) VALUES ($1, %d, $2, $5), ($1, %d, $3, $5), ($1, %d, $4, $5) """ % (population_id, dwellings_id, occupied_dwellings_id)) for region_id, statistics in self._region_statistics.items(): c.execute('EXECUTE insert_region_values (%s, %s, %s, %s, %s)', (region_id, statistics.population, statistics.n_dwellings, statistics.n_occupied_dwellings, statistics.note)) connection.commit()
def exists(mid, threshold = 1, con = None): import db if con == None: conn = db.connect() cur = conn.cursor() cur.execute('SELECT user_id, timestamp FROM microblogs WHERE mid = %s LIMIT 1'%(mid)) res = cur.fetchone() if res == None: print 'lastblog: [warning] blogs of MID %s not found'%(mid) res = False else: uid, post_time = res time_str = datetime.datetime.strftime(post_time, '%Y-%m-%d %H:%M:%S') cur.execute('SELECT mid FROM microblogs WHERE user_id = %s and timestamp < "%s" LIMIT %d'%( uid, time_str, threshold )) mids = cur.fetchall() res = not ((mids is None) or (len(mids) < threshold)) cur.close() if con == None: conn.close() return res
def get(mid, con = None): import db if con == None: conn = db.connect() cur = conn.cursor() cur.execute('SELECT user_id, timestamp FROM microblogs WHERE mid = %s LIMIT 1'%(mid)) res = cur.fetchone() if res == None: print 'lastblog: [warning] blogs of MID %s not found'%(mid) res = None else: uid, post_time = res time_str = datetime.datetime.strftime(post_time, '%Y-%m-%d %H:%M:%S') cur.execute('SELECT mid, timestamp FROM microblogs WHERE user_id = %s and timestamp < "%s" ORDER BY timestamp DESC'%(uid, time_str)) res = cur.fetchall() cur.close() if con == None: conn.close() return res
def add_one_card(pic,fid,main): conn=connect() cursor=conn.cursor() cursor.execute("insert into card(pic,fid,main) values(%s,%s,%s)",[pic,fid,main]) conn.commit() cursor.close() conn.close()
def main(): con = db.connect() cur = con.cursor() emo_mids = {} limit = 25000000 pbar = progbar.start(limit) i = 0 cur.execute("SELECT mid, text FROM microblogs WHERE comments_count > 0 AND comments_count < 100 LIMIT %d"%(limit)) for mid, text in cur: text, emos = blogger.extract(text) if len(emos) > 0 and len(emos) < 6: samples = blogger.prepare_sample(text, emos) for e, t in samples: if emo_mids.has_key(e): emo_mids[e].append(mid) else: emo_mids[e] = [mid, ] i += 1 pbar.update(i) pbar.finish() cPickle.dump(emo_mids, open('../output/emo_mids.pkl', 'w'))
def update(self): conn = db.connect(settings.DATABASE) raw_data = db.getdata(conn) if raw_data == None: logger.info("data is None, skipping ui update...") return raw_data = list(raw_data) conn.close() if not raw_data: logger.info("no data, skipping ui update...") return data = sorted(raw_data, reverse=True)[:settings.WINDOWSIZE] i, pairs = data[0] logger.info(str((i, pairs))) self.vars = [var for [var, val] in pairs] self.data = {} for (i, pairs) in data: for [var, val] in pairs: if var in self.vars: self.data.setdefault(var, []) self.data[var].append(val) self.hists = {} for var in self.vars: self.hists[var] = hist(self.data[var])
def change_pic(cid,pic): conn=connect() cursor=conn.cursor() cursor.execute("update card set pic=%s where cid=%s",[pic,cid]) conn.commit() cursor.close() conn.close()
def main(): import db source_db = db.connect() worker = create_worker(source_db, 256) work_queue = _WorkQueue(source_db, 'work_queue2', ['zoom_level', 'tile_row', 'tile_column'], worker) work_queue.work()
def get_dataset(): con = connect() sql = '''SELECT symbol, date, open, high, low, close, volume FROM time_series_daily WHERE date >= '2018-01-01' ORDER BY date;''' # sql = '''SELECT symbol, date, open, high, low, close, volume FROM time_series_daily WHERE date < '2018-01-01' ORDER BY date;''' ds = pd.read_sql_query(sql, con) con.close() return ds
def main(): """Connect to DB""" cur, conn = connect() print("AWS Redshift connection established OK.") load_staging_tables(cur, conn) insert_tables(cur, conn) conn.close()
def new_user(newUser): cnx = db.connect() cursor = cnx.cursor(dictionary=True) answer = users.new_user(json.loads(newUser), cursor) cursor.close() cnx.commit() cnx.close() return answer
def cuisineFinder(id): conn = db.connect() cursor = conn.cursor() result = cursor.execute( "SELECT cuisine from restaurants where RID={id}".format( id=id)).fetchone() return json.dumps(result)
def get_area_id_by_name(area_name): connection = db.connect(db.config) with connection.cursor() as cursor: sql = "SELECT id FROM area WHERE name = %s" cursor.execute(sql, (area_name, )) result = cursor.fetchone()[0] db.close(connection) return result
def weekAnalyze(userid): conn = db.connect() cursor = conn.cursor() sql = "select SUM(f.carbohydrate) as car, SUM(f.protein) as pro, SUM(f.fat) as fat from diet as d JOIN food as f on d.food_id = f.food_id where user_id=%d and d.date between DATE_ADD(NOW(), INTERVAL -1 WEEK) AND NOW();"%(userid) cursor.execute(sql) result = cursor.fetchall()[0] db.close(conn) return result['car'], result['pro'], result['fat']
def create_relationships(): print("Creating relationships...") with db.connect() as driver: with driver.session() as session: tx = session.begin_transaction() for query in queries: tx.run(query) tx.commit()
def getIngredientData(): conn, cur = connect() ingredient_counts = get_total_ingredient_counts(conn) disconnect(conn, cur) return json.loads((json.dumps(ingredient_counts, indent=2)))
def run(): batch_time = datetime.now().replace(microsecond=0) conn = db.connect() rows = [] rows.append(sync_data(conn, "zutrittsberechtigte-nr.json", "Nationalrat", batch_time)) rows.append(sync_data(conn, "zutrittsberechtigte-sr.json", "Ständerat", batch_time)) conn.close() print_summary(rows, batch_time)
def get_transactions_for_user(uid): with db.connect() as cursor: cursor.execute( "SELECT * from transactions where sender = %s or receiver = %s", (uid, uid)) return cursor.fetchall() return None
def __init__(self, list_pid, app_name = "local", min_support = 0.15 , min_confidence = 0.6, max_iterations = 50): self.min_support = min_support self.min_confidence = min_confidence self.conn = db.connect(app_name) self.cursor = self.conn.cursor() self.max_iterations = max_iterations self.list_pid = list_pid
def main(): ''' Run some tests. ''' logging.basicConfig(level=logging.INFO) db_conn = db.connect('enwiki.labsdb', 'enwiki_p', '~/replica.my.cnf') local_db_conn = db.connect('tools.labsdb', 's53463__actrial_p', '~/replica.my.cnf') datapoints = gather_historic(local_db_conn, db_conn, dt.date(2016, 4, 14), dt.date(2016, 4, 15)) print('got {} data points'.format(len(datapoints))) # print(datapoints[0]) print(datapoints) return ()
def test_add_match_non_existing_player(players): res = slackbot.handle_command( "match <@{}> <@XXXXXXXXX> nd 11 0".format(test_user_id), test_user_id) conn, cursor = db.connect() matches = db.get_matches(cursor) conn.close() assert res == responses.player_does_not_exist() assert len(matches) == 0
def players(): conn, cursor = db.connect() p1 = Player(test_user_id, "erlend", 1000) p2 = Player(pingpongbot_id, "pingpong", 1000) db.create_player(cursor, p1) db.create_player(cursor, p2) conn.commit() conn.close() yield p1, p2
def db_connect(self): ''' Connect to the Tool database and the replicated Wikipedia database. ''' try: self.wiki_db_conn = db.connect(self.wiki_host, self.wiki_db_name, self.db_config) except: raise DatabaseConnectionError try: self.tool_db_conn = db.connect(self.tool_host, self.tool_db, self.db_config) except: raise DatabaseConnectionError ## all ok return ()
def get_school_info(school_id): conn = db.connect(settings.DB_HOST, settings.DB_USER, settings.DB_PASSWD, settings.DB_NAME) # school uf school_uf = db.get_school_uf(conn, school_id) if school_uf is not None: uf_score_avg = db.get_uf_score_avg(conn, school_uf) school_city = db.get_school_city(conn, school_id) if school_city is not None: city_score_avg = db.get_city_score_avg(conn, school_city) # num students total_students = db.get_total_lines(conn, school_id) total_absents = db.get_total_absents(conn, school_id) # avg avg_score1, avg_score2, avg_score3, avg_score4, avg_score5, avg_total = db.get_score_avg(conn, school_id) # sex score_avg_sex = db.get_score_avg_sex(conn, school_id) # score interval score_count = [ db.get_count_per_score_interval(conn, 0, 0, school_id), db.get_count_per_score_interval(conn, 1, 99, school_id), db.get_count_per_score_interval(conn, 100, 199, school_id), db.get_count_per_score_interval(conn, 200, 299, school_id), db.get_count_per_score_interval(conn, 300, 399, school_id), db.get_count_per_score_interval(conn, 400, 499, school_id), db.get_count_per_score_interval(conn, 500, 599, school_id), db.get_count_per_score_interval(conn, 600, 699, school_id), db.get_count_per_score_interval(conn, 700, 799, school_id), db.get_count_per_score_interval(conn, 800, 899, school_id), db.get_count_per_score_interval(conn, 900, 999, school_id), db.get_count_per_score_interval(conn, 1000, 1000, school_id) ] db.close_connection(conn) score_interval_data = [ ['notas', 'alunos', { 'role': 'annotation' }], ["0", int(score_count[0]), int(score_count[0])], ["1-99", int(score_count[1]), int(score_count[1])], ["100-199", int(score_count[2]), int(score_count[2])], ["200-299", int(score_count[3]), int(score_count[3])], ["300-399", int(score_count[4]), int(score_count[4])], ["400-499", int(score_count[5]), int(score_count[5])], ["500-599", int(score_count[6]), int(score_count[6])], ["600-699", int(score_count[7]), int(score_count[7])], ["700-799", int(score_count[8]), int(score_count[8])], ["800-899", int(score_count[9]), int(score_count[9])], ["900-999", int(score_count[10]), int(score_count[10])], ["1000", int(score_count[11]), int(score_count[11])] ] return render_template('school_info.html', **locals())
def getScoreboard(): '''If row with specified id exists, creates and returns corresponding ORM instance. Otherwise Exception raised.''' with db.connect() as conn: cursor = conn.cursor() cursor.execute("SELECT U.username, U.highest_score FROM Users U ORDER BY U.highest_score") return [{'username': row['username'], 'highest_score': row['highest_score']} for row in cursor]
def del_mes(id_chat, id_message, id_user): conn = connect() cur = conn.cursor() cur.execute('update from "Messages" set "del_mes"= 1 where "id_chat" = ' + id_chat.__str__() + ' and "id_message" = ' + id_message.__str__() + ' and "id_user" = ' + id_user.__str__()) conn.commit() conn.close() return
def main(): with open('items.csv', 'r', newline='') as csv_file: csv_reader = csv.DictReader(csv_file) with db.connect() as conn: with conn.cursor() as cur: for row in csv_reader: cur.execute( 'INSERT INTO items (wiki_link, canonical_name) VALUES (%s, %s)', (row['wiki_link'], row['name']))
def search_word_user(word, userId): cnx = db.connect() cursor = cnx.cursor(dictionary=True) register.searches(word, cursor) resp = jsonify(main.get_result_user(word, userId, cursor)) cursor.close() cnx.commit() cnx.close() return resp
def get_user_id(username): with db.connect() as cursor: cursor.execute("SELECT id from users where username = %s", (username.lower(), )) result = cursor.fetchone() return result["id"] if result else None return None
def test(verbose): """Test database connectivity.""" utils.configureLogging(verbose) config = utils.loadConfig() logging.debug(f"Testing DB connection...") db_conn = db.connect(config["DB_HOST"], config["DB_NAME"], config["DB_USER"], config["DB_PASS"]) logging.info(db.show_version(db_conn)) db.close(db_conn)
def connect(self): '''Connect to the appropriate Wikipedia and user databases.''' try: self.wiki_db_conn = db.connect(self.wiki_host, self.wiki_db_name, self.db_config) except: raise DatabaseConnectionError try: self.tool_db_conn = db.connect(self.tool_host, self.tool_db, self.db_config) except: raise DatabaseConnectionError ## all ok return()
def post_later(endpoint, payload): """ Store the POST data in the database for sending later. """ sql = db.connect() posts = sql['posts'] postId = posts.insert(dict(endpoint=endpoint, payload=json.dumps(payload))) l.warning("Failed to send %s to photostreamer-server endpoint %s. Saved for resend as ID %d.", payload, endpoint, postId)
def getprogrambyid(id): dbase = db.connect() cursor = dbase.cursor() cursor.execute("SELECT * FROM coursedetails WHERE id = %d" % (id)) data = cursor.fetchone() coursename = data[1] cursor.close() dbase.close() return coursename
def _(): (vodlist, paginationlist) = WebSession().get(plugin.path, VodShowParser()) db.connect() items = [] for path, rating in vodlist: poster, label, info = db.fetchone_vod(path) item = ListItem(label, poster=poster, info=info, rating=rating) items.append((plugin.url_for(path), item, True)) for path, title in paginationlist: item = ListItem(title, properties={'SpecialSort': 'bottom'}) items.append((plugin.url_for(path), item, True)) db.close() xbmcplugin.setContent(plugin.handle, 'tvshows') xbmcplugin.addDirectoryItems(plugin.handle, items, len(items)) xbmcplugin.endOfDirectory(plugin.handle)
def register(regno, fname, lname, courseid, year): dbase = db.connect() cursor = dbase.cursor() cursor.execute( "INSERT INTO students (regnumber, firstname, surname, courseid, year) values ('%s', '%s', '%s', %d, %d)" % (regno, fname, lname, courseid, year)) dbase.commit() cursor.close() dbase.close()
def run(): global db db = connect(host=args.mongo_host, port=args.mongo_port) loop = asyncio.get_event_loop() loop.run_until_complete(login_accounts(accounts, args.cookie_dir)) loop.run_until_complete(login_guests()) app = web.Application() app.add_routes(routes) web.run_app(app, host=args.host, port=args.port)
def updateScore(username, data): score = data['score'] '''Writes back instance values into database''' with db.connect() as conn: cursor = conn.cursor() cursor.execute("UPDATE Users SET highest_score = ? WHERE username = ? AND highest_score>?", (score, username, score)) conn.commit() return