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()
