def __init__(self, root): # Connection used to check if the database is setup correctly. Is discarded no matter the outcome. self.temp_conn = database.create_connection(database.db) self.thread_id = threading.get_ident() MainWindow.__init__(self, root) if setup.wrong_schema(self.temp_conn) or database.wrong_item_count( self.temp_conn): self.temp_conn.close() InstallPage(self.root) else: self.temp_conn.close() self.conn = database.create_connection(database.db) self.username_label = ttk.Label(text='Username') self.password_label = ttk.Label(text='Password') self.title_login_label = ttk.Label(text='Log-In', width='48', style='big.TLabel', anchor='center') self.login_page_username_entry = ttk.Entry( validate='key', validatecommand=(self.is_alnum, '%P'), invalidcommand=self.failed_is_alnum) self.login_page_password_entry = ttk.Entry( validate='key', validatecommand=(self.is_alnum, '%P'), invalidcommand=self.failed_is_alnum) self.login_page_login_button = Button( text='Log-in', bg='gray', command=self.login_page_login_command) # self.login_page_login_button = Button(text='Log-in', bg='gray') self.login_page_signup_button = Button( text='Sign-up', bg='gray', command=lambda: SignupPage(self.root)) # self.login_page_signup_button = Button(text='Sign-up', bg='gray') self.title_login_label.grid(column=0, row=0, sticky=W + E) self.username_label.grid(column=0, row=1) self.login_page_username_entry.grid(column=0, row=2) self.password_label.grid(column=0, row=3) self.login_page_password_entry.grid(column=0, row=4) self.login_page_login_button.grid(column=0, row=5) self.login_page_signup_button.grid(column=0, row=6) static_functions.clear_entry(self.login_page_username_entry) static_functions.clear_entry(self.login_page_password_entry) self.login_page_username_entry.focus() self.center([820, 178])
def onOpenCase(self, event): openFileDialog = wx.FileDialog( self, "Open", "", "", "*.db", #creates a filedialog that only allow user to select .db files wx.FD_OPEN | wx.FD_FILE_MUST_EXIST) openFileDialog.ShowModal() global caseDbPath caseDbPath = openFileDialog.GetPath() #get path selected in filedialog global caseDetails, openTabs try: #conn = connectdb.create_connection(caseDbPath) #try to connect to case database and get case and evidence details self.conn = connectdb.create_connection(caseDbPath) caseDetails = connectdb.select_case_details(self.conn) #conn) self.evidenceDetails = connectdb.select_evidence_details( self.conn ) #conn) #get EvidenceName, EvidenceDbPath, EvidenceDatatime and Md5 from case database self.addAuiTab("Summary", self.evidenceDetails) #opens summary page openTabs.append("Summary") self.recreateTree(caseDbPath) except: pass #ignore if try: fails openFileDialog.Destroy()
def status(*args): """ Calculates server time, amount of users, online users & messages. :return: dict of all calculated data :rtype: { "status": bool, "time": str, "users_count": int, "messages_count": int, "users_online": int } """ connection = create_connection("data.sqlite3") select_users_count = "SELECT Count(*) FROM users" users_count = execute_read_query(connection, select_users_count, 0) select_messages_count = "SELECT Count(*) FROM messages" messages_count = execute_read_query(connection, select_messages_count, 0) users_online = len(get_online(None, None)) connection.close() return { "status": True, "time": datetime.now().strftime("%d/%m/%Y, %H:%M:%S"), "users_count": users_count[0], "messages_count": messages_count[0], "users_online": users_online, }
def send_message(): """ Stores the message, time of sending and username of author in database. :request: { "username": str, "text": str } :return: dict of execution status :rtype: {"ok": bool} """ data = request.json username = data["username"] text = data["text"] connection = create_connection("data.sqlite3") select_user_id = f"SELECT id FROM users WHERE username LIKE :username" query_data = execute_read_query(connection, select_user_id, 0, {'username': username}) data_dict = {'text': text, 'id': query_data[0]} new_message = f"INSERT INTO messages (text, time, user_id) " \ f"VALUES (:text, strftime('%s','now'), :id)" execute_query(connection, new_message, data_dict) connection.close() return {'ok': True}
def get_messages(): """ Collects new messages after specified point of time. :request: ?after=1234567890.4 - point of time :return: new messages after specified point :rtype: { "messages": [ {"username": str, "text": str, "time": float}, ... ] } """ after_time = float(request.args['after']) new_messages = [] connection = create_connection("data.sqlite3") select_messages = f"SELECT m.text, m.time, u.username FROM messages m " \ f"INNER JOIN users u " \ f"ON m.user_id = u.id " \ f"WHERE m.time > :after" query_data = execute_read_query(connection, select_messages, 1, {'after': after_time}) # Generate messages. for data in query_data: message = {'username': data[2], 'text': data[0], 'time': data[1]} new_messages.append(message) connection.close() return {"messages": new_messages}
def __init__(self, root): self.conn = database.create_connection(database.db) MainWindow.__init__(self, root) self.title_char_select_label = ttk.Label(text='Character Selection', width='48', style='big.TLabel', anchor='center') self.characters_label = ttk.Label(text='Characters') self.chars_combo = ttk.Combobox(postcommand=self.populate_combo) self.select_button = Button(text='Select', bg='gray', command=self.select_command) self.delete_button = Button(text='Delete', bg='gray', command=self.delete_command) self.logout_button = Button(text='Log-out', bg='gray', command=self.logout_command) self.character_creation_button = Button( text='Character creation', bg='gray', command=lambda: CharacterCreationPage(self.root)) self.title_char_select_label.grid(column=0, row=0, sticky=W + E) self.characters_label.grid(column=0, row=1) self.chars_combo.grid(column=0, row=2) self.select_button.grid(column=0, row=3) self.delete_button.grid(column=0, row=4) self.logout_button.grid(column=0, row=5, sticky=W + S) self.character_creation_button.grid(column=0, row=5, sticky=E + S) self.chars_combo.focus()
def __init__(self, root): self.conn = database.create_connection(database.db) MainWindow.__init__(self, root) self.title_char_creation__label = ttk.Label(text='Character Creation', width='48', style='big.TLabel', anchor='center') self.currency_label = ttk.Label(text='Currency') self.name_label = ttk.Label(text='Name') self.name_entry = ttk.Entry(validate='key', validatecommand=(self.is_alpha, '%P'), invalidcommand=self.failed_is_alpha) self.currency_entry = ttk.Entry(validate='key', validatecommand=(self.is_digit, '%P'), invalidcommand=self.failed_is_digit) self.create_character_button = Button( text='Create', bg='gray', command=self.create_character_command) self.logout_button = Button(text='Log-out', bg='gray', command=self.logout_command) self.title_char_creation__label.grid(column=0, row=0, sticky=W + E) self.name_label.grid(column=0, row=1) self.name_entry.grid(column=0, row=2) self.currency_label.grid(column=0, row=3) self.currency_entry.grid(column=0, row=4) self.create_character_button.grid(column=0, row=5) self.logout_button.grid(column=0, row=6) self.name_entry.focus()
def fix_timelines(): config = configparser.ConfigParser() config.read('config.ini') progress_log = setup_logger('progress', str(config['PARMS']['s_logfile']) + '.log') API = APIManager(config['API']['key']) database_connection = db.create_connection( (config['DATABASE']['name'] + '.db')) progress_log.info("Trying to fix missing timelines!") matches = db.get_missing_timelines(database_connection) if matches == (-1): progress_log.info("No missing timelines found!") return for match in matches: progress_log.info("Working on match {}...".format(match[0])) match_timeline = API.get_match_timeline(match[0]) time.sleep(1.4) if match_timeline is None: progress_log.warning( "Getting match timeline for matchId {} failed!".format( match[0])) continue db.update_timeline(database_connection, match[0], match_timeline)
def main(): if not create_connection("users.sqlite"): sys.exit(1) parser = argparse.ArgumentParser( description="Interface de cliente. " "Utilizada para o realizar diversas operações visando movimentação de dinheiro" ) group = parser.add_mutually_exclusive_group() group.add_argument('--saque', dest='saque', action='store_true') group.add_argument('--deposito', dest='deposito', action='store_true') group.add_argument('--visualizar', dest='visualizar', action='store_true') group.add_argument('--simular', dest='simular', action='store_true') args = parser.parse_args() if args.saque: conta = input("Conta: ") senha = input("Senha: ") saque(conta, senha) if args.deposito: conta = input("Conta: ") senha = input("Senha: ") deposito(conta, senha) if args.visualizar: conta = input("Conta: ") visualizar(conta) if args.simular: simular()
def __init__(self, root): # Removes the DB file. There's is no way to reach this page without creating a DB file first. os.remove(database.db) self.conn = database.create_connection(database.db) self.count = 0 # TODO: I don't think I use max_count. I could, but I don't think I am. Maybe make private class var? # TODO: Check count via 'count' dictionary in api. Hard code as maximum for install bar. self.max_count = 256 MainWindow.__init__(self, root) if setup.wrong_schema(self.conn): self.title_install_label = ttk.Label(text='Installing....', width='48', style='big.TLabel', anchor='center') self.install_bar = ttk.Progressbar(root, orient=HORIZONTAL, length=200, mode='determinate') self.install_button = Button(text='Install', bg='gray', command=self.start) self.title_install_label.grid(column=0, row=0, sticky=W + E) self.install_bar.grid(column=0, row=1) self.install_button.grid(column=0, row=2) else: LoginPage(self.root) self.center()
def get_online(username, args=None): """ Checks if there're online users. With no args parameter searches for all online users. With specified args parameter searches only for specified ones. User's data tuple contains: - username - is active (1 - Yes, 0 - No) - date of last activity in seconds :param username: who executed the command :param args: list of usernames, optional :return: list of tuples with users' data about their activity """ connection = create_connection("data.sqlite3") if args: select_users = f"SELECT username, is_active, last_active " \ f"FROM users " \ f"WHERE username IN ({','.join(['?'] * len(args))})" query_data = execute_read_query(connection, select_users, 1, args) else: query_data = execute_read_query(connection, select_queries['select_active_users']) connection.close() return query_data
def make_query5_onClick(self): compared_value = float(self.entry_query5.get()) connect_db = database.create_connection(self.db) regulargrade, midgrade, premiumgrade, diesel = database.query5( connect_db, self.db_name, compared_value) database.close_connection(connect_db) if regulargrade: print("Última data em que o combustível Regular estava abaixo de", compared_value, ":", regulargrade[0]) else: print("Combustível Regular nunca esteve abaixo do valor", compared_value) if midgrade: print("Última data em que o combustível MidGrade estava abaixo de", compared_value, ":", midgrade[0]) else: print("Combustível MidGrade nunca esteve abaixo do valor", compared_value) if premiumgrade: print("Última data em que o combustível Premium estava abaixo de", compared_value, ":", premiumgrade[0]) else: print("Combustível Premium nunca esteve abaixo do valor", compared_value) if diesel: print("Última data em que o Diesel estava abaixo de", compared_value, ":", diesel[0]) else: print("Diesel nunca esteve abaixo do valor", compared_value)
def onConfirm(self, event): #create case dir dirPath = self.txtCaseFolder.GetValue() #get case folder path casePath = Path(dirPath) if casePath.is_dir(): #check if it exist print("dir exist") else: os.mkdir(dirPath) #create if does not #create case database dbFilePath = self.txtCaseDb.GetValue() #get case database path my_file = Path(dbFilePath) #print(dbFilePath) if my_file.is_file(): #check if file exist print("file exist") else: conn = connectdb.create_connection(dbFilePath) #creates db file and connection if it does not exist caseInfoTable = "CREATE TABLE 'CaseInfo' ( 'CaseID' INTEGER PRIMARY KEY AUTOINCREMENT, 'InvestigatorName' TEXT, 'CaseNum' INTEGER, 'CaseName' TEXT, 'CaseFolder' TEXT, 'CaseDb' TEXT, 'CaseDesc' TEXT, 'Datetime' TEXT);" evidenceInfoTable = "CREATE TABLE 'EvidenceInfo' ('CaseID' INTEGER, 'EvidenceName' TEXT, 'EvidenceDbPath' TEXT, 'EvidenceDatetime' TEXT, 'Md5' TEXT, 'EvidencePath' TEXT, 'EvidenceSize' TEXT);" bookmarksTable = "CREATE TABLE 'Bookmarks' ('fileName' TEXT, 'ctime' TEXT, 'crtime' TEXT, 'atime' TEXT, 'mtime' TEXT, 'uid' INTEGER, 'gid' INTEGER, 'md5' TEXT, 'size' INTEGER, 'parentPath' TEXT, 'extension' TEXT, 'image' TEXT);" connectdb.createTable(conn, caseInfoTable) #creates CaseInfo table connectdb.createTable(conn, evidenceInfoTable) #creates EvidenceInfo table connectdb.createTable(conn, bookmarksTable) #creates Bookmarsk table connectdb.createFilesEvidenceTable(conn) connectdb.createSessionsEvidenceTable(conn) connectdb.createDNSEvidenceTable(conn) connectdb.createCredentialsEvidenceTable(conn) #insert case details with conn: caseDetails = (self.txtInvestigatorName.GetValue(), self.txtCaseNum.GetValue(), self.txtCaseName.GetValue(), self.txtCaseFolder.GetValue(), self.txtCaseDb.GetValue(), self.txtCaseDescription.GetValue(), datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) connectdb.insertCaseDetails(conn, caseDetails) #insert case details to CaseInfo self.Close()
def __init__(self, bot): self.bot = bot conn = create_connection('raid_db') if conn: logger.info("RaidCog connected to raid database.") create_table(conn, 'raid') create_table(conn, 'player', columns=self.role_names) create_table(conn, 'assign') else: logger.error("RaidCog could not create database connection!") self.conn = conn self.raids = select(conn, 'raids', 'raid_id') logger.info("We have loaded {} raids in memory.".format(len( self.raids))) # Emojis host_guild = bot.get_guild(self.host_id) if not host_guild: host_guild = bot.guilds[0] logger.info("Using emoji from {0}.".format(host_guild)) emojis = {} for emoji in host_guild.emojis: if emoji.name in self.role_names: emojis[emoji.name] = str(emoji) self.class_emojis_dict = emojis self.class_emojis = list(emojis.values()) # Run background task self.background_task.start()
def update_table(): conn = database.create_connection('bod.db') sql = 'DELETE FROM weather WHERE 1' conn.execute(sql) conn.commit() complete_url = "https://yandex.kg/weather/yaroslavl/month" response = requests.get(complete_url) content = response.content soup = BeautifulSoup(content, "html.parser") table = soup.find('div', attrs={'class': 'climate-calendar'}) days = table.find_all( 'div', attrs={'class': 'climate-calendar-day__detailed-container-center'}) purchases = [] for day in days: try: day_day = day.find( 'h6', attrs={'class': 'climate-calendar-day__detailed-day'}) day_temp = day.find('span', attrs={'class': 'temp__value'}) table = day.find( 'table', attrs={'class': 'climate-calendar-day__detailed-data-table'}) table_tr = table.find('tr') day_dav = table_tr.find_all('td')[1] day_vla = table_tr.find_all('td')[3] purchases.append((date.today(), day_day.text, day_temp.text, day_dav.text, day_vla.text)) except Exception as e: print(e) conn.executemany('INSERT INTO weather VALUES (?,?,?,?,?)', purchases) conn.commit()
def make_query4_onClick(self): compared_value = float(self.entry_query4.get()) connect_db = database.create_connection(self.db) regulargrade, midgrade, premiumgrade, diesel = database.query4( connect_db, self.db_name, compared_value) database.close_connection(connect_db) print("\nResultado da Query:\n", regulargrade, midgrade, premiumgrade, diesel) if regulargrade: print("Data em que o combustível Regular ultrapassou", compared_value, ":", regulargrade[0]) else: print("Combustível Regular ainda não ultrapassou o valor", compared_value) if midgrade: print("Data em que o combustível MidGrade ultrapassou", compared_value, ":", midgrade[0]) else: print("Combustível MidGrade ainda não ultrapassou o valor", compared_value) if premiumgrade: print("Data em que o combustível Premium ultrapassou", compared_value, ":", premiumgrade[0]) else: print("Combustível Premium ainda não ultrapassou o valor", compared_value) if diesel: print("Data em que o Diesel ultrapassou", compared_value, ":", diesel[0]) else: print("Diesel ainda não ultrapassou o valor", compared_value)
def main(argv): db_file = r"/Users/jlyi/Desktop/Meme Image Captioning/src/memes.db" connection = database.create_connection(db_file) rows = database.select_all_images(connection) rows2 = database.select_all_descriptions(connection) # needs rework, won't always grab the name of the meme off KnowYourMeme.com ''' if (strc_simil(argv[0], rows) == None): filePath = '/Users/jlyi/Desktop/MemeCaption/img/test3.png' searchUrl = 'http://www.google.hr/searchbyimage/upload' multipart = {'encoded_image': (filePath, open(filePath, 'rb')), 'image_content': ''} response = requests.post(searchUrl, files=multipart, allow_redirects=False) fetchUrl = response.headers['Location'] raw = get(fetchUrl).text page = fromstring(raw) for result in page.cssselect(".r a"): url = result.get("href") if url.startswith("/url?"): url = parse_qs(urlparse(url).query)['q'] print(url[0]) ''' index = strc_simil(argv[0], rows) print(rows2[index]) print('------------------------------') print(read_text(argv[0]))
def insert_data_onClick(self): # Create the table to insert data (if it doesn't exist yet) connect_db = database.create_connection(self.db) database.create_table(connect_db, self.db_name) database.close_connection(connect_db) # Insert the data from the csv file into the table created connect_db = database.create_connection(self.db) database.insert_data_on_database(connect_db, self.db_name, self.filename) database.close_connection(connect_db) ########### Test Query ########### connect_db = database.create_connection(self.db) database.search_data_test(connect_db, self.db_name) database.close_connection(connect_db)
def __init__(self, parent, caseDetails, evidenceDetails): # begin wxGlade: MyFrame.__init__ wx.Panel.__init__(self, parent=parent) self.SetSize((655, 673)) self.panel_1 = wx.Panel(self, wx.ID_ANY) self.panel_2 = wx.ScrolledWindow(self.panel_1, wx.ID_ANY, style=wx.TAB_TRAVERSAL) self.txtCaseDb = wx.TextCtrl(self.panel_1, wx.ID_ANY, "", style=wx.TE_READONLY | wx.BORDER_NONE) self.txtCaseDesc = wx.TextCtrl(self.panel_1, wx.ID_ANY, "", style=wx.TE_MULTILINE | wx.TE_READONLY) global evidenceInfo for x in caseDetails: try: conn = connectdb.create_connection( x[5]) #call to get evidence database from evidence table evidenceInfo = connectdb.select_evidence_details(conn) except Error as e: print(e) self.__set_properties() self.__do_layout(caseDetails, evidenceDetails)
def check_levels(): config = configparser.ConfigParser() config.read('config.ini') database_connection = db.create_connection( (config['DATABASE']['name'] + '.db')) summoner_name = config['PARMS']['summoner'] data = get_stats(database_connection, summoner_name) levels = [] for data_part in data: stats = eval(data_part[0]) levels.append(stats['champLevel']) nth_percentile = 75 growth = 2 base = 30 diffs = [(n, scaling(base, growth, n)) for n in range(1, 19)] print(tabulate(diffs, headers=["level", "diff"])) print("Median: %.1f, Mean: %.1f, %dth percentile: %.1f" % (round(np.median(levels), 1), round(np.mean(levels), 1), nth_percentile, round(np.percentile(levels, nth_percentile), 1)))
def scrape_shelf(shelf_link): genre = shelf_link.split('/')[-1] connection = create_connection() page = 1 response = requests.get(shelf_link + f"?page={page}", headers={ 'Cookie': cookie}, ) while response.status_code != 404: page += 1 soup = BeautifulSoup(response.content, 'html.parser') books = soup.select("div.leftContainer div.elementList") for book in books: regex = r"\d\.\d\d?" regex2 = r" ((\d{1,3},)?)*\d{1,3} " book_obj = {} item = book.select('div.left')[0] ratings = item.findChildren('span', class_='greyText smallText')[0].getText() book_obj['avg rate'] = re.search(regex, ratings).group() book_obj['number of ratings'] = re.search(regex2, ratings).group().replace(',', ' ') book_obj['title'] = item.findChildren('a', class_='bookTitle')[0].getText() book_obj['author'] = item.findChildren('a', class_='authorName')[0].getText() insert_stuff(book_obj['title'], book_obj['author'], genre, book_obj['avg rate'], book_obj['number of ratings'], 'tbd', connection) response = requests.get(shelf_link + f"?page={page}", headers={ 'Cookie': cookie}, ) connection.close()
def sauve_base_de_donnes(): conn = database.create_connection() requete = "Select * From nom_des_voies;" requete = "Select voie_id, voie_complet, voie_fantoir, voie_date_cre, voie_real, voie_officiel, tenant, aboutissant, denom_annee, dm_seance, delib_num, cote_archives, denom_origine, lien_externe, observation, geojson, genre From nom_des_voies order by voie_id;" try: cur = database.query_create_select(conn, requete) print("apres query") # voie_id, voie_complet, voie_fantoir, voie_date_cre, voie_real, voie_officiel, tenant, aboutissant, denom_annee, dm_seance, delib_num, cote_archives, denom_origine, lien_externe, observation, geojson, genre fichier = open("sauvegarde_base_de_donnees.txt", "w") for row in cur: print(row[0]) ligne_fichier = "" print("Début: ") for j in range(0, 17): print(row[j]) ligne_fichier = ligne_fichier + ";" + str(row[j]) print(ligne_fichier) fichier.write(ligne_fichier[1:] + "\n") fichier.close() except Exception as inst: print(type(inst)) # the exception instance print(inst.args) # arguments stored in .args
def sign_up_user(): """ Register user. Confirms whether login and password are in range and whether user exist. Hashes and encrypts password using :func:`codec`. Stores user's data in database. request: { "username": str, "password": str } :return: dict of execution status :rtype: { "login_out_of_range": bool, "password_out_of_range": bool, "ok": bool } """ username = request.authorization.username password = request.authorization.password # Make sure credentials are in range. if len(username) not in range(4, 20, 1): return {"login_out_of_range": True} elif len(password) not in range(4, 20, 1): return {"login_out_of_range": False, "password_out_of_range": True} connection = create_connection("data.sqlite3") select_user = f"SELECT id FROM users WHERE username LIKE :username" query_data = execute_read_query(connection, select_user, 0, {'username': username}) # If user isn't registered, encrypt password and store in database. if query_data is None: password_hash = codec(password, 1) password_hash = Binary(password_hash) data_dict = {'username': username, 'password_hash': password_hash} create_user = f"INSERT INTO users (username, password_hash, registered)" \ f"VALUES (:username, :password_hash, strftime('%s','now'))" execute_query(connection, create_user, data_dict) else: connection.close() return { "login_out_of_range": False, "password_out_of_range": False, 'ok': False } connection.close() return { "login_out_of_range": False, "password_out_of_range": False, 'ok': True }
def __init__(self, bot): self.bot = bot conn = create_connection('raid_db') if conn: logger.info("CalendarCog connected to raid database.") else: logger.error("CalendarCog could not create database connection!") self.conn = conn
def loadBookmarks(self): conn = connectdb.create_connection(caseDb) #connect to case database bookmarkQuery = connectdb.selectBookmarks( conn) #lookup bookmarks table for x in bookmarkQuery: self.list_ctrl.Append( (x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8], x[9], x[10], x[11])) #apped to listctrl
def test_seats_unreserved_correct_reservation_size( self): # Print the correct number of remaining seats conn = database.create_connection("ZooManagement.db") curr = conn.cursor() total = 110 cap = 150 database.seats_unreserved(conn, total, cap) self.assertEqual(cap - total, 40)
def test_wash_dino(self): conn = database.create_connection("ZooManagement.db") curr = conn.cursor() database.wash_dino(curr, "Hippo") curr.execute( "select Day_Of_Last_Bath from dinosaurs where type = 'Hippo'") self.assertEqual(curr.fetchone()[0], datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
def next(): global videoID global ARGS global total_input global score global last_words input = list() urls = list() for i in range(ARGS): input.append(request.args.get(str(i))) if request.args.get(str(i)) == last_words[i]: score += 1 total_input += input ARGS = 0 last_words.clear() input.clear() session['CURR_LINE_NUM'] += 1 curr_list = lines_words[session['CURR_LINE_NUM']] last_words = curr_list.copy() conn = database.create_connection("database.db") for i in range(len(curr_list)): rows = database.select_img(conn, curr_list[i].strip(",.!?")) if rows != None: urls.append(rows[0]) dynamic_image = open('templates/images.html', 'w+') if len(urls) <= 4: width = 100/5 html = '''<div class="row justify-content-center" style="margin:20px;">''' for i in range(len(urls)): html += '''<div class=dynamic_image style="width: ''' + str(width) + '''%"><img src="''' + urls[i] + '''" class="dynamic_image"><br><input name="''' + str(i) + '''"type="text" class=dynamic_image></div>''' ARGS += 1 html += '''</div>''' elif len(urls) <= 8: width = 100/len(urls) html = '''<div class="row justify-content-center" style="margin:20px;">''' for i in range(len(urls)): html += '''<div class=dynamic_image style="width: ''' + str(width) + '''%"><img src="''' + urls[i] + '''" class="dynamic_image"><br><input name="''' + str(i) + '''"type="text" class=dynamic_image></div>''' ARGS += 1 html += '''</div>''' else: width = 100/8 html = '''<div class="row justify-content-center" style="margin:20px;">''' for i in range(8): html += '''<div class=dynamic_image style="width: ''' + str(width) + '''%"><img src="''' + urls[i] + '''" class="dynamic_image"><br><input name="''' + str(i) + '''"type="text" class=dynamic_image></div>''' ARGS += 1 html += '''</div>''' html += '''<div class="row justify-content-center" style="margin:20px;">''' for i in range(8, len(urls)): html += '''<div class=dynamic_image style="width: ''' + str(width) + '''%"><img src="''' + urls[i] + '''" class="dynamic_image"><br><input name="''' + str(i) + '''"type="text" class=dynamic_image></div>''' ARGS += 1 html += '''</div>''' dynamic_image.write(html) dynamic_image.close() return render_template('normal.html')
def fix_ranks(): config = configparser.ConfigParser() config.read('config.ini') progress_log = setup_logger('progress', str(config['PARMS']['s_logfile']) + '.log') API = APIManager(config['API']['key']) database_connection = db.create_connection( (config['DATABASE']['name'] + '.db')) progress_log.info("Trying to fix missing ranked info!") summoners = db.get_missing_ranks(database_connection) if summoners == (-1): progress_log.info("No missing rankings found!") return for summoner in summoners: progress_log.info("Working on summoner {}, match {}...".format( summoner[0], summoner[1])) ranked_info = API.get_summoner_ranked_info(summoner[0]) time.sleep(1.3) if ranked_info is None: progress_log.warning( "Getting summoner ranked info for summoner {} failed!".format( summoner[0])) continue if len(ranked_info) == 0: progress_log.warning( "Ranked info for summoner {} empty! Treating as unraked!". format(summoner[0])) rank = str("Unranked") wins = -1 losses = -1 db.update_ranking(database_connection, summoner[0], summoner[1], rank, wins, losses) continue flag = False for ranked in ranked_info: if ranked['queueType'] == "RANKED_SOLO_5x5": rank = str(ranked['tier']) + " " + str(ranked['rank']) wins = int(ranked['wins']) losses = int(ranked['losses']) db.update_ranking(database_connection, summoner[0], summoner[1], rank, wins, losses) flag = True if not flag: progress_log.info( "Soloqueue rank for summoner {} not found, treating as unranked..." .format(summoner[0])) rank = str("Unranked") wins = -1 losses = -1 db.update_ranking(database_connection, summoner[0], summoner[1], rank, wins, losses)
def start(path: str, database: str = "mydatabase", user: str = "postgres", password: str = "12345", host: str = "127.0.0.1", port: str = "5432", n: int = 0) -> None: """ Gets the name of the file with path to it and optional parameters The body of service Creates psql connection and database Then reads .csv or .xlsx file, gets column names and types from it Then adds data if the table with such name already exists Creates the table and adds the data inside if the table with such name doesn't exist :param path: the name of the file with path to it :param database: name of the database :param user: name of psql user :param password: password of psql user :param host: host :param port: port :param n: number of row with headers """ register_adapter(np.int64, psycopg2._psycopg.AsIs) connection = create_connection("postgres", user, password, host, port) create_database_query = "CREATE DATABASE " + database create_database(connection, create_database_query) connection = create_connection(database, user, password, host, port) table, table_name = read_file(path, n) cursor = connection.cursor() cursor.execute( "select * from information_schema.tables where table_name=%s", (table_name, )) columns, data, types = preprocess(table) if bool(cursor.rowcount): insert(columns, data, table_name, connection) connection.commit() else: create_table(types, table_name, connection) insert(columns, data, table_name, connection) connection.commit()
def __init__(self, minimize=False): """Initialize main window, systemtray, global hotkey, and signals. Args: minimize: True, minimize to system tray. False, bring window to front. """ super(MainWindow, self).__init__() self.setWindowTitle(APP_NAME) self.setWindowIcon(QtGui.QIcon(utils.resource_filename('icons/clipmanager.ico'))) # Remove minimize and maximize buttons from window title self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint| QtCore.Qt.CustomizeWindowHint| QtCore.Qt.WindowCloseButtonHint) # Connect to database and create tables self.db = database.create_connection(STORAGE_PATH) database.create_tables() # Create main widget that holds contents of clipboard history self.main_widget = MainWidget(self) self.setCentralWidget(self.main_widget) # Create system tray icon if not QtGui.QSystemTrayIcon.isSystemTrayAvailable(): logging.warn('cannot find a system tray.') QtGui.QMessageBox.warning(self, 'System Tray', 'Cannot find a system tray.') self.tray_icon = systemtray.SystemTrayIcon(self) self.tray_icon.activated.connect(self._on_icon_activated) self.tray_icon.show() # Return OS specific global hot key binder and set it self.key_binder = hotkey.Binder(self) self._set_hot_key() # Toggle window from system tray right click menu self.connect(self.tray_icon, QtCore.SIGNAL('toggle-window()'), self._on_toggle_window) # Open settings dialog from right click menu on system tray and view self.connect(self.tray_icon, QtCore.SIGNAL('open-settings()'), self._on_open_settings) self.connect(self.main_widget, QtCore.SIGNAL('open-settings()'), self._on_open_settings) # Show window if not minimize: self._on_toggle_window()
def create_edges_full_data_table(): print('create_edges_full_data_table') connection = database.create_connection() database.run_command('delete from edges_full_data', None, connection, True) database.run_command('vacuum', None, connection, True) sql_query = 'select a.id, a.shape_x_y, b.x from_x, b.y from_y, c.x to_x, c.y to_y \ from oulu_edges a \ inner join oulu_nodes b on a.`from` = b.id \ inner join oulu_nodes c on a.`to` = c.id' count = 0 edges = database.query_all(sql_query, None, connection) for edge in edges: sequence = 1 if edge['shape_x_y'] is None: distance = utility.measure_distance(edge['from_x'], edge['from_y'], edge['to_x'], edge['to_y']) if distance <= config.MAX_DISTANCE: sql_script = ' insert into "edges_full_data" ("edge_id", "sequence", "from_x", "from_y", "to_x", "to_y", "distance") \ values (?, ?, ?, ?, ?, ?, ?)' parameter = (edge['id'], sequence, edge['from_x'], edge['from_y'], edge['to_x'], edge['to_y'], distance) database.run_command(sql_script, parameter, connection, True) sequence += 1 else: splited_dots = split_line(edge['from_x'], edge['from_y'], edge['to_x'], edge['to_y'], config.MAX_DISTANCE) for i in range(len(splited_dots)-1): splited_distance = utility.measure_distance(splited_dots[i][0], splited_dots[i][1], splited_dots[i+1][0], splited_dots[i+1][1]) sql_script = ' insert into "edges_full_data" ("edge_id", "sequence", "from_x", "from_y", "to_x", "to_y", "distance") \ values (?, ?, ?, ?, ?, ?, ?)' parameter = (edge['id'], sequence, splited_dots[i][0], splited_dots[i][1], splited_dots[i+1][0], splited_dots[i+1][1], splited_distance) database.run_command(sql_script, parameter, connection, False) sequence += 1 database.commit(connection) else: lines = edge['shape_x_y'].split(' ') for i in range(len(lines)-1): coord_from = lines[i].split(',') coord_to = lines[i+1].split(',') distance = sqrt(pow(float(coord_from[0]) - float(coord_to[0]), 2) + pow(float(coord_from[1]) - float(coord_to[1]), 2)) if distance <= config.MAX_DISTANCE: sql_script = ' insert into "edges_full_data" ("edge_id", "sequence", "from_x", "from_y", "to_x", "to_y", "distance") \ values (?, ?, ?, ?, ?, ?, ?)' parameter = (edge['id'], sequence, coord_from[0], coord_from[1], coord_to[0], coord_to[1], distance) database.run_command(sql_script, parameter, connection, False) sequence += 1 else: splited_dots = split_line(coord_from[0], coord_from[1], coord_to[0], coord_to[1], config.MAX_DISTANCE) for j in range(len(splited_dots)-1): splited_distance = utility.measure_distance(splited_dots[j][0], splited_dots[j][1], splited_dots[j+1][0], splited_dots[j+1][1]) sql_script = ' insert into "edges_full_data" ("edge_id", "sequence", "from_x", "from_y", "to_x", "to_y", "distance") \ values (?, ?, ?, ?, ?, ?, ?)' parameter = (edge['id'], sequence, splited_dots[j][0], splited_dots[j][1], splited_dots[j+1][0], splited_dots[j+1][1], splited_distance) database.run_command(sql_script, parameter, connection, False) sequence += 1 database.commit(connection) count += 1 if count%1000 == 0: print(count) database.close_connection(connection, True) print('finish create_edges_full_data_table')
#! /usr/bin/python import database as db if __name__ == "__main__": # Create PostgreSQL database connection and a cursor object conn = db.create_connection() cursor = conn.cursor() # Query control table query = "SELECT * FROM public.etlcolumns;" cursor.execute(query) rows = cursor.fetchall() # Update data types for columns in control table for row in rows: table_schema = row[0] table_name = row[1] column_name = '"' + row[2] + '"' data_type = row[3] update_column = 'ALTER TABLE %s.%s ALTER COLUMN %s SET DATA TYPE %s USING (%s::%s);' % (table_schema,table_name,column_name,data_type,column_name,data_type) print(update_column) cursor.execute(update_column) # Commit executions and close connection conn.commit() conn.close()