def new_game(): # get group_name from form & initiating user's turn if request.method == "POST": group_name = request.form.get("group") # check that no game started with group where one of members is currently in an active game activeusers = query_db( "SELECT users.user_id FROM games INNER JOIN groups ON groups.group_name=games.group_name INNER JOIN users ON users.user_id=groups.user_id WHERE games.active=?", [ True, ], one=False) members = query_db("SELECT user_id FROM groups WHERE group_name=?", [group_name], one=False) if len(members) < 3: flash( group_name + " does not have enough players. Add at least 3 to start a game." ) return redirect("/") intersection = [value for value in activeusers if value in members] if intersection: flash("One or more members of selected group is busy playing.") return redirect("/") row = query_db("SELECT * FROM groups WHERE group_name=? AND user_id=?", [group_name, session["user_id"]], one=True) # new DB entry for new game get_db().execute( "INSERT INTO games (active, turn, group_name) VALUES (:active, :turn, :group_name)", { "active": 1, "turn": row["turn"], "group_name": row["group_name"] }) get_db().commit() session["userrow"] = query_db( "SELECT * FROM games INNER JOIN groups ON groups.group_name=games.group_name INNER JOIN users ON users.user_id=groups.user_id WHERE users.user_id=? AND games.active=?", [session["user_id"], 1], one=True) session["gamerow"] = query_db( "SELECT * FROM groups INNER JOIN games ON games.group_name=groups.group_name INNER JOIN users ON groups.user_id=users.user_id WHERE groups.user_id=? AND games.active=?", [session["user_id"], 1], one=True) session["round"] = 1 return render_template("live_game.html", turn=row["turn"], round=session["round"], isturn=True, group_name=group_name) else: groups = query_db("SELECT group_name FROM groups WHERE user_id=?", [session["user_id"]], one=False) return render_template("new_game.html", groups=groups)
def leave_group(group): # Disallow leaving active group if session["gamerow"]["group_name"] == group: flash( group + " is currently playing with you. End game before leaving the group." ) return redirect("/groups") get_db().execute("DELETE FROM groups WHERE user_id=? AND group_name=?", (session["user_id"], group)) get_db().commit() flash("You left " + group + "!") return redirect("/groups")
def get_max_datetime(self, table_name): """ Calculates and returns the maximum date up to which data is already present in DB Parameter: name of table """ db = get_db() query = '''select {} from {}'''.format(self.column_check_date, table_name) cursor = db.cursor() try: cursor.execute(query) result = cursor.fetchall() dates = list() for item in result: dates.append(self.__get_datetime(item[0])) db.close() return max(dates) except Exception as e: try: db.close() except: pass print "Exception while generating max date :", e Logger.log('error', "Exception while generating max date : {}.".format(e)) return None
def truncate_table(self, table_name): """ Truncates a given table Parameter: table name """ db = get_db() query = "truncate table {}".format(table_name) cursor = db.cursor() cursor.execute(query) db.close()
def print_tail(db, lines, filter): database = get_db(db) with cd(database['home']): latest_log = "" if len(filter) > 0: latest_log = run( "ls -ltr | grep %s | awk 'END{print}' | awk {'print $9'};" % filter) else: latest_log = run("ls -ltr | awk 'END{print}' | awk {'print $9'};") if len(latest_log) > 0: print run('tail -n-%s %s' % (lines, latest_log))
def sign_up(): # Clear session session.clear() #Ensure all fields filled out also if JS disabled if request.method == "POST": name = request.form.get("username") if not name: return apology("Please provide username") if not request.form.get("password") or not request.form.get( "confirmation"): return apology("Please provide password and confirm it") hashp = generate_password_hash(request.form.get("password"), method='pbkdf2:sha256', salt_length=8) if not check_password_hash(hashp, request.form.get("confirmation")): return apology("Password does not match confirmation.") try: cur = get_db().execute( "INSERT INTO users (name, hash) VALUES (:name, :hash)", { "name": name, "hash": hashp }) get_db().commit() except sqlite3.IntegrityError: return apology("Username already exists") # Login user automatically, storing their id in session, then layout will also show index.html? &menu? session["user_id"] = query_db("SELECT user_id FROM users WHERE name=?", [name], one=True)["user_id"] session["name"] = query_db("SELECT name FROM users WHERE user_id=?", [session["user_id"]], one=True)["name"] return render_template("index.html") else: return render_template("sign_up.html")
def _ycsb_execution_status(db): """ Shows whether the job is:q complete""" database = get_db(db) with cd(database['home']): latest_out_log = run( "ls -ltr | grep *.out | awk 'END{print}' | awk {'print $9'};") if len(latest_out_log) > 0: # Check for errors latest_err_log = run( "ls -ltr | grep .err | awk 'END{print}' | awk {'print $9'};") permissible_errors = '' if 'permissablerunerrors' in get_db(db): permissible_errors = " ".join([ '| grep -v ' + s for s in get_db(db)['permissablerunerrors'] ]) print permissible_errors lines_in_error_log = run( 'cat %s %s | grep -v "^ [0-9].*sec" | wc -l' % (latest_err_log, permissible_errors)) if int(lines_in_error_log) > 8: ycsb.do_get_log(db) run('tail -n 100 %s ' % latest_err_log) raise Exception( 'Looks like there is something in the error log: %s : %s lines' % (latest_err_log, int(lines_in_error_log))) # Check for completion complete = run('cat %s | grep "\[OVERALL\]" | wc -l' % latest_out_log) run('tail -n-4 %s' % latest_out_log) if int(complete) > 0: print 'YCSB has completed on %s' % env.host return 1 return 0
async def main(): db = get_db() try: ps = Queue() for ep in db._all(): while ps.qsize() > limit_concurrent_requests: logging.debug('Queue too big! Waiting for some to finish') await ps.get() ps.put(asyncio.create_task(refresh_ep(ep, db))) while not ps.empty(): await ps.get() except: pass finally: db.close()
def sell_stock(username, symbol, amount): data = lookup(symbol) price = data['price'] cash_to_add = price * amount db = get_db() with db: current_shares = db.cursor().execute('SELECT amount FROM holdings WHERE username = ? and symbol = ?', (username, symbol)).fetchone() current_shares = current_shares[0] if amount == current_shares: db.cursor().execute('DELETE FROM holdings WHERE symbol = ?', (symbol, )) else: remaining_shares = current_shares - amount db.cursor().execute('UPDATE holdings SET amount = ? WHERE username = ? AND symbol = ?', (remaining_shares, username, symbol)) db.cursor().execute('UPDATE users SET cash = ? WHERE username = ?', (cash_to_add + get_user_cash(), username)) sql = 'INSERT INTO transactions (username, company, symbol, price, amount, value, type, date) VALUES(?,?,?,?,?,?,?,?)' date = str(datetime.now()) tuple = (username, data['company'], data['symbol'], data['price'], amount, cash_to_add, 'sell', date) db.cursor().execute(sql, tuple)
def next(): if request.method == "POST": # insert written sentence into group's game group_name = session["gamerow"]["group_name"] newsentence = request.form.get("newsentence") if number_sentences(newsentence) > 1: flash("Please write only one sentence.") return redirect("/live_game") get_db().execute( "INSERT INTO sentences (game_id, sentence, group_name, user_id, time) VALUES (:game_id, :sentence, :group_name, :user_id, :timestamp)", { "game_id": session["gamerow"]["game_id"], "sentence": newsentence, "group_name": group_name, "user_id": session["gamerow"]["user_id"], "timestamp": datetime.now() }) # get current turn, max turn (# of players), increment & insert to DB turn = session["userrow"]["turn"] maxturn = query_db("SELECT MAX(turn) FROM groups WHERE group_name=?", [group_name], one=True)["MAX(turn)"] turn = 1 if turn == maxturn else turn + 1 get_db().execute("UPDATE games SET turn=? WHERE game_id=?", (turn, session["userrow"]["game_id"])) get_db().commit() player_id = query_db( "SELECT user_id FROM groups WHERE group_name=? AND turn=?", [session["gamerow"]["group_name"], turn], one=True)["user_id"] player = query_db("SELECT name FROM users WHERE user_id=?", [player_id], one=True)["name"] session["round"] += 1 return render_template("live_game.html", round=session["round"], group_name=group_name, player=player)
def end_game(): if request.method == "POST": group_name = session["gamerow"]["group_name"] newsentence = request.form.get("newsentence") get_db().execute( "INSERT INTO sentences (game_id, sentence, group_name, user_id, time) VALUES (:game_id, :sentence, :group_name, :user_id, :timestamp)", { "game_id": session["gamerow"]["game_id"], "sentence": newsentence, "group_name": group_name, "user_id": session["gamerow"]["user_id"], "timestamp": datetime.now() }) get_db().execute("UPDATE games SET active=? WHERE group_name=?", (0, group_name)) get_db().commit() session["round"] = None session["userrow"] = None session["gamerow"] = None return redirect("/archive")
from helpers import get_db import json conn = get_db() cur = conn.cursor() cur.execute("select features from products where product_id=45") product = cur.fetchone()[0] for (k, v) in product.items(): print(k) print(v) print("=============") # print(product.keys()) # print(product['اقلام همراه هارد دیسک']) # print(product.keys())
def insert_db(self, data, table_name, data_updated_till, id_prefix): """ Inserts data to a given table Parameters: data from the API name of table maximum datetime up to which data is already update in the table prefix of id of table """ print "inside insert_db method" db = get_db() # Fetching columns in API fieldnames_api = data.next() fieldnames_api = [ item.lower().replace(" : ", "_").replace(" ", "_").replace("-", "_") for item in fieldnames_api ] try: column_check_date_index = fieldnames_api.index( self.column_check_date) except: print "WARNING !! {} not found in API response, GOING TO INSERT ALL DATA TO DATABASE.".format( ' '.join(self.column_check_date.split('_'))) Logger.log( 'warning', "{} not found in API response, GOING TO INSERT ALL DATA TO DATABASE." .format(' '.join(self.column_check_date.split('_')))) column_check_date_index = None # Fetching columns already present in out DB table query = "show columns from {}".format(table_name) cursor = db.cursor() cursor.execute(query) result = cursor.fetchall() fieldnames_db = list() for item in result[1:]: fieldnames_db.append(item[0]) difference = list(set(fieldnames_api) - set(fieldnames_db)) if len(difference) > 0: print "found new column(s)." Logger.log('info', "found new column(s).") try: self.__alter_table_collumn_add(db, table_name, difference) except Exception as e: print "Exception during alter table :", e Logger.log('error', "Exception during alter table : {}".format(e)) return None # fields structure to build the insert query if table_name == "inventory_master_db": fields = "%s, " * (len(fieldnames_api) + 2) else: fields = "%s, " * (len(fieldnames_api) + 1) fields = fields[:-2] max_id = self.__get_current_max_id(db, id_prefix, table_name) max_id = int(max_id) # fields to build the query string for building the insert query query_str = '' for item in fieldnames_api: query_str += item + ", " query_str = query_str + self.nmk_id_field if table_name == "inventory_master_db": query_str = query_str + ", last_modified" # building the final insert query query = '''insert into {} ({}) values ({})'''.format( table_name, query_str, fields) cursor = db.cursor() # Append id in each row of data to be inserted in DB table final_data = list() for row in data: row = [str(item) for item in row] if (column_check_date_index is not None) and (data_updated_till is not None): try: current_row_date_value = row[column_check_date_index] date = self.__get_datetime(current_row_date_value) except Exception as e: continue if data_updated_till < date: max_id += 1 final_data.append( self.__append_id(id_prefix, row, max_id, table_name)) else: max_id += 1 final_data.append( self.__append_id(id_prefix, row, max_id, table_name)) if (column_check_date_index is not None) and (data_updated_till is not None): print "Number of new row(s) found : {}".format(len(final_data)) Logger.log( 'info', "Number of new row(s) found : {}".format(len(final_data))) # If we have values to be inserted in table then we insert all data at once if len(final_data): try: print "inserting data into table '{}'".format(table_name) Logger.log('info', "inserting data into table '{}'".format(table_name)) row_count = cursor.executemany(query, final_data) db.commit() print "Number of row(s) inserted : {}".format(row_count) Logger.log('info', "Number of row(s) inserted : {}".format(row_count)) except Exception as e: print "Database insertion exception :", e Logger.log('error', "Database insertion exception : {}".format(e)) db.close()
def new_group(): if request.method == "POST": group_name = request.form.get("group_name") if not group_name: flash("Please choose a group name!") return redirect("/new_group") if query_db("SELECT * FROM groups WHERE group_name=?", [group_name], one=True) is not None: flash("Group name not available.") return redirect("/new_group") # set turn in group (for game) to 0 before looping turn = 0 # get usernames typed into fields[] for field in zip(request.form.getlist("fields[]")): if not field[0]: flash("Please select player") return redirect("/new_group") user_id = query_db("SELECT user_id FROM users WHERE name=?", [field[0]], one=True) # check that user not duplicated in form AND group # if user enters inexistent username, remove all entries if user_id is None: get_db().execute("DELETE FROM groups WHERE group_name=?", (group_name, )) get_db().commit() flash(field[0] + " is not registered") return redirect("/new_group") # if username entered is already in group, remove all entries checkusers = query_db( "SELECT user_id FROM groups WHERE group_name=?", [group_name], one=False) if checkusers: for check in checkusers: print("CHECK IS:", check["user_id"]) if (turn > 0) and (user_id["user_id"] == check["user_id"]): get_db().execute( "DELETE FROM groups WHERE group_name=?", (group_name, )) get_db().commit() flash(field[0] + " is already added to " + group_name) return redirect("/new_group") turn += 1 try: get_db().execute( "INSERT INTO groups (group_name, turn, user_id) VALUES (:group_name, :turn, :user_id)", { "group_name": group_name, "turn": turn, "user_id": user_id["user_id"] }) get_db().commit() except sqlite3.IntegrityError: return apology("something went wrong in DB") return redirect("/groups") else: return render_template("new_group.html")
item_id, { 'id': item_id, 'series': series_name, 'last_title': current_title, 'checked_since': now, 'needs_title': needs_title, 'needs_thumb': needs_thumb }) if __name__ == '__main__': if len(sys.argv) != 4: args = [] for a in sys.argv: args.append(a) logging.error('Incorrect number of arguments! ARGS=%s' % args) sys.exit() item_type = sys.argv[1] item_id = sys.argv[2] item_isvirtual = sys.argv[3].lower() in ['1', 'true'] if item_type != 'Episode' or item_isvirtual: # Exit if item is virtual or is not an episode logging.info( f'Item is virtual. Exiting. ARGS={item_id};{item_type};{item_isvirtual}' ) sys.exit() db = get_db() asyncio.run(check_episode(item_id, db)) db.close()
import sys import glob import unittest from gluon.globals import Request # Pre-requisites & settings # ----------------------------------------------------------------------------- APP_NAME=request.application sys.path.append("applications/" + APP_NAME + "/tests/unit") import helpers auth = db.auth manager = db.manager helpers.USE_TEST_DB = True db = helpers.get_db(DAL, db, clean=True) if helpers.USE_TEST_DB: # run models over test db for zzz_1st_roles, etc model_files = glob.glob('applications/'+APP_NAME+'/models/*.py') for model_file in model_files: execfile(model_file, globals()) # Unit Tests # ----------------------------------------------------------------------------- class OrgAuthTests(unittest.TestCase): def setUp(self): #self.test_org_id = db.org_organisation.insert( #name="OrgAuthTest Org 1", #acronym="OATO1")
import sys import glob import unittest from gluon.globals import Request # Pre-requisites & settings # ----------------------------------------------------------------------------- APP_NAME=request.application sys.path.append("applications/" + APP_NAME + "/tests/unit") import helpers auth = db.auth manager = db.manager helpers.USE_TEST_DB = True db = helpers.get_db(DAL, db, clean=True) if helpers.USE_TEST_DB: # run models over test db for zzz_1st_roles, etc model_files = glob.glob('applications/'+APP_NAME+'/models/*.py') for model_file in model_files: execfile(model_file, globals()) # Unit Tests # ----------------------------------------------------------------------------- class OrgAuthTests(unittest.TestCase): def setUp(self): #self.test_org_id = db.org_organisation.insert( #name="OrgAuthTest Org 1", #acronym="OATO1")
async def main(): if not api_token or not base_url: logging.critical('Either your api_token or base_url is blank!') sys.exit() api_json = {"X-Emby-Token": api_token} headers = { "user-agent": "mozilla/5.0 (windows nt 10.0; win64; x64) applewebkit/537.36 (khtml, like gecko) chrome/81.0.4044.138 safari/537.36" } headers.update(api_json) years = datetime.now().year if len( sys.argv) == 1 else None if sys.argv[1].lower() in ['all', 'none' ] else sys.argv[1] logging.warning(f'Years={years}') raw_data = { 'IncludeItemTypes': 'Episode', 'Years': years, 'Recursive': True, 'IsMissing': False, } def get_items(params): res = requests.get(f'{base_url}/Items', params=params, headers=headers) try: data = json.loads(res.text) except json.decoder.JSONDecodeError: print(res.text) return [] items = [] for item in data.get('Items'): id = item.get("Id") items.append(id) return items ids = [] if not check_thumbs: for q in ['Episode ', 'TBA']: raw_data.update({'NameStartsWith': q}) ids += get_items(raw_data) if check_thumbs: ids = get_items(raw_data) logging.warning(f'Checking {len(ids)} ids!') with alive_bar(len(ids), bar='blocks', spinner='dots_waves2') as bar: db = get_db() async def run_with_progress(id): await check_episode(id, db) bar() # Optimal qsize limit might be 8 # 3 = 59.9 # 5 = 61.4 # 7 = 58.5 # 8 = 64 # 9 = 59.5 # 10 = 57.6 ps = Queue() for id in ids: while ps.qsize() > limit_concurrent_requests: await ps.get() ps.put(asyncio.create_task(run_with_progress(id))) while not ps.empty(): await ps.get() db.close()
def add(group): if request.method == "POST": # set turn in group (for game) to highest before looping to add new members turn = query_db("SELECT MAX(turn) FROM groups WHERE group_name=?", [group], one=True)["MAX(turn)"] old_size = turn users = [] # get usernames typed into fields[] for field in zip(request.form.getlist("fields[]")): if not field[0]: flash("Please select player(s)") return render_template("add.html", group=group) user = query_db("SELECT user_id FROM users WHERE name=?", [field[0]], one=True) # store users added in list to flash users.append(field[0]) # check that user not duplicated in form AND group # if user enters inexistent username, remove all entries if user is None: get_db().execute( "DELETE FROM groups WHERE group_name=? AND turn>?", (group, old_size)) get_db().commit() flash(field[0] + " is not registered") return redirect("/groups") # if username entered is already in group, remove all entries checkusers = query_db("SELECT user_id FROM groups WHERE group_name=?", [group], one=False) if checkusers: for check in checkusers: print("CHECK IS:", check["user_id"]) if (turn >= old_size) and (user["user_id"] == check["user_id"]): get_db().execute( "DELETE FROM groups WHERE group_name=? AND turn>?", (group, old_size)) get_db().commit() flash(field[0] + " is already added to " + group) return redirect("/groups") turn += 1 print("USERS ARE: ", users) try: get_db().execute( "INSERT INTO groups (group_name, turn, user_id) VALUES (:group_name, :turn, :user_id)", { "group_name": group, "turn": turn, "user_id": user["user_id"] }) get_db().commit() except sqlite3.IntegrityError: return apology("something went wrong in DB") flash(", ".join(users) + " added!") return render_template("group.html", group=group) else: return render_template("add.html", group=group)