def __init__(self) -> None:
self.root = Tk()
self.root.geometry("300x370+0+0")
# self.root.resizable(True, True)
self.root.eval("tk::PlaceWindow . center")
self.root.title("Чеботарёв Степан ПКС-405")
self.root.iconphoto(False, PhotoImage(file=config_get("icon_path")))
self.Frame = None
self.database_manager = DatabaseManager()
# ? Fonts
self.font_color = "#37474F"
self.font_color_complementary = "#78909C"
self.font_color_accent = "#FF9C1A"
self.font_captcha = ("Curlz MT", 24)
self.font_20 = (
"Arial",
20,
)
self.font_24 = (
"Arial",
24,
)
self.font_28 = (
"Arial",
28,
)
def post(self, blogId, blogStatus):
try:
whereClause = {'_id': ObjectId(blogId)}
data = DatabaseManager.find(Post, whereClause)
if len(data) == 0 or len(data) > 1:
formattedResponse = ResponseHandler.formatResponse(
'POST_NOT_FOUND')
return formattedResponse, formattedResponse['statusCode']
postInstance = data[0]
postInstance.status = blogStatus
result = DatabaseManager.update(postInstance)
formattedResponse = ResponseHandler.formatResponse(
'POST_UPDATE_SUCCESS')
return formattedResponse, formattedResponse['statusCode']
except Exception as e:
logging.error(traceback.format_exc())
formattedResponse = ResponseHandler.formatResponse(
'POST_UPDATE_FAILED', exception=e)
return formattedResponse, formattedResponse['statusCode']
def callback():
code = request.args.get('code')
url = 'https://accounts.spotify.com/api/token'
resp = requests.post(url=url,
data={
'grant_type': 'authorization_code',
'code': code,
'redirect_uri': SPOTIFY_REDIRECT_URI,
'client_id': SPOTIFY_CLIENT_ID,
'client_secret': SPOTIFY_CLIENT_SECRET
})
if resp.status_code != 200:
print resp.json()
else:
token = resp.json()
access_token = '%s %s' % (token['token_type'], token['access_token'])
refresh_token = token['refresh_token']
resp = requests.get(url='https://api.spotify.com/v1/me',
headers={'Authorization': access_token})
if resp.status_code == 200:
user_data = resp.json()
manager = DatabaseManager(DATABASE)
manager.create_user(session['telegram_user'],
session['telegram_first_name'],
user_data['id'], access_token, refresh_token)
return redirect('/')
def register():
db_manager = DatabaseManager()
username = request.json.get('username')
password = sha512_crypt.encrypt(request.json.get('password'), salt=app.config['SECURITY_PASSWORD_SALT'], rounds=5000)
email = request.json.get('email')
# Check if everything filled in
if username is None or password is None or email is None:
return abort(400) # missing arguments
# Check if already exists
elif db_manager.username_exists(username) or db_manager.email_exists(email):
# username and/or email do already exist
return response_cache_header("ERROR, username and/or email do already exist", cache_control="no-cache")
else:
db_manager.create_user(username=username, password_hash=password, email=email, email_verified=False)
# Email verification
token = generate_confirmation_token(email)
confirm_url = url_for('verify_email', token=token, _external=True)
html = render_template('email.html', confirm_url=confirm_url)
subject = "Please confirm your email"
send_email(email, subject, html)
return response_cache_header("Successfully created user, please verify email.\n", cache_control="no-cache")
def classify(song_id, activity):
manager = DatabaseManager(DATABASE)
return jsonify({
'code': 1,
'updated': manager.classify_song(song_id, activity)
})
def createCharacter(account, name, model):
if hasPlayer(name):
raise CharacterAlreadyExists()
try:
ID = idFactory.createID()
# these values are only for test puporse, must be tested and fixed
# all players stats must be saved on DB
if model == 1:
spd = 2
df = 2
fc = 2
hp = 300
elif model == 2:
spd = 1
df = 2
fc = 3
hp = 350
elif model == 3:
spd = 3
df = 1
fc = 2
hp = 250
DB.getInstance().query("INSERT INTO Players (ID, account, name, speed, defense, `force`, maxHp, hp, model)" \
"Values (%s,%s,%s,%s,%s,%s,%s,%s,%s)",(ID,account,name,spd,df,fc,hp,hp,model))
except Exception, e:
print e
return False
def user_scripts():
token = request.query['token']
if not DatabaseManager.check_session(token):
return HTTPResponse(status=401)
user_id = DatabaseManager.get_user_id(request.query['user'])
_response = {'scripts': [dict(x) for x in DatabaseManager.get_user_scripts(user_id)]}
return HTTPResponse(status=200, body=json.dumps(_response))
def execute_on_torrent_downloaded_actions(self):
"""
Execute onTorrentDownloaded action
"""
curs = DatabaseManager.Instance().cursor
# "SELECT id, data FROM AutomatedActions WHERE `trigger`='onTorrentDownloaded' AND notifier='TvShowManager';"
actions = self.actions["onTorrentDownloaded"]
# for a in curs:
# actions.append(a)
for id_, data in actions.items():
id_ = int(id_)
try:
self.logger.info("try to execute action id=%d", id_)
success = self.execute_action(data)
self.logger.info("action (id=%d) result=%d", id_, success)
delete = success
except KeyError:
self.logger.info(
"error while processing action (id=%d) torrent does not exist",
id_)
delete = True
finally:
pass
if delete:
self.logger.info("remove action with id=%d", id_)
delete_query = "DELETE FROM AutomatedActions WHERE id=%s;"
curs.execute(delete_query, (id_, ))
DatabaseManager.Instance().connector.commit()
def authorize_user(login, password):
if len(DatabaseManager.get_user(login, password)) != 0:
token = secrets.token_hex(20)
DatabaseManager.add_session(login, token)
return token
else:
return "0"
def emulation_info_state(uuid):
state_info = {}
state_ref = dbm.retrieve_save_state(uuid=uuid)[0]
other_save_states = dbm.retrieve_save_state(game_uuid=state_ref['game_uuid'])
state_extra_files = dbm.retrieve_file_path(save_state_uuid=uuid)
state_info['record'] = state_ref
state_info['availableStates'] = filter(lambda s: True if s.get('save_state_source_data') or s.get('rl_starts_data') else False, other_save_states)
state_info['fileMapping'] = {k: os.path.join('/game_data', v, k.split('/')[-1]) for k, v in map(lambda x: (x['file_path'], x['source_data']),
state_extra_files)} if state_extra_files else None
state_info['fileInformation'] = {f['file_path']: f for f in state_extra_files}
# Save data is singular, and probably LZMA compressed
if state_ref['save_state_source_data']:
state_info['stateFileURL'] = os.path.join('/cite_data', state_ref['save_state_source_data'], '{}'.format(state_ref['uuid']))
# Save data is multiple and probably run length encoded
if state_ref['rl_starts_data'] and state_ref['rl_lengths_data']:
state_info['rlStartsURL'] = os.path.join('/cite_data', state_ref['rl_starts_data'], '{}'.format(state_ref['uuid']))
state_info['rlLengthsURL'] = os.path.join('/cite_data', state_ref['rl_lengths_data'], '{}'.format(state_ref['uuid']))
if state_extra_files:
main_exec = dbm.retrieve_file_path(save_state_uuid=uuid, main_executable=True)[0]
state_info['gameFileURL'] = os.path.join('/game_data', main_exec['source_data'], main_exec['file_path'].split('/')[-1])
else:
game_ref = dbm.retrieve_game_ref(state_ref['game_uuid'])
state_info['gameFileURL'] = os.path.join('/game_data', game_ref['source_data'], game_ref['data_image_source'])
return jsonify(state_info)
class PlayerScraper:
def __init__(self, season, force_retrieval=False):
self.force_retrieval = force_retrieval
self.parser = PlayerParser()
self.season = season
self.database_manager = DatabaseManager()
self.numeric_cols = []
def request_players_from_web(self):
player_stat_page = "http://www.basketball-reference.com/leagues/NBA_{0}_totals.html".format(
str(self.season + 1))
r = urllib2.urlopen(player_stat_page)
return r
def fetch_players(self):
if len(self.database_manager.get_players(
self.season)) == 0 or self.force_retrieval:
# We want to get the remote copy, regardless if we have it already.
print "fetching players remotely"
page = self.request_players_from_web()
df = self.parser.parse_player_page(page)
df.reset_index(inplace=True)
df["season"] = self.season
df = df.apply(pd.to_numeric, errors='ignore')
print df.loc[:, 'efg_pct']
[
self.database_manager.add_player(v)
for k, v in df.to_dict(orient='index').iteritems()
]
return self.database_manager.get_players(self.season)
def __init__(self):
self.databaseManager = DatabaseManager()
self.communicationManager = CommunicationManager()
self.file_type = self.databaseManager.get_file_type()
self.seed_path = self.databaseManager.get_seed_path()
self.seed_file = self.databaseManager.get_seed_file()
self.mutate_path = self.databaseManager.get_mutate_path()
self.crash_path = self.databaseManager.get_crash_path()
self.target_path = self.databaseManager.get_target_path()
self.work_summary = None
self.loop = self.databaseManager.get_loop()
self.test_number = self.databaseManager.get_test_number()
self.mutate_mode = self.databaseManager.get_mutate_mode() # windows binary or docker container
self.stop = False
self.pid = None
self.debug = None
self.event = None
self.debug_time = 0
self.system_bit = self.databaseManager.get_system_bit()
require_directorys = [self.seed_path, self.mutate_path, self.crash_path]
for directory in require_directorys:
if not os.path.exists(directory):
os.makedirs(directory)
def cli(ctx, verbose, no_prompts):
ctx.obj = dict() # Context object that stores application state in dict, could make class at some point
ctx.obj['VERBOSE'] = verbose
ctx.obj['NO_PROMPTS'] = no_prompts
# Check for ucon64
try:
devnull = open(os.devnull)
subprocess.Popen(['ucon64'], stdout=devnull, stderr=devnull).communicate()
except OSError as e:
if e.errno == os.errno.ENOENT:
click.echo("WARNING: ucon64 not installed. Required for NES, SNES and N64 rom info.")
# Check for data root
if not os.path.exists(LOCAL_DATA_ROOT):
click.echo("Local data root not found, creating {}".format(LOCAL_DATA_ROOT))
os.makedirs(LOCAL_DATA_ROOT)
# Check for tables, extracted, game citation and performance citation
dbm.create_tables()
# Check for data directory
for data_path, path_name in ((LOCAL_GAME_DATA_STORE, "game data"), (LOCAL_CITATION_DATA_STORE, "citation data")):
if not os.path.exists(data_path):
click.echo("Local {} store: '{}' not found, creating...".format(path_name, data_path))
os.makedirs(data_path)
def _add_message(self, data):
database = DatabaseManager()
security = Security()
user = security.user
password = security.password
database.connect(dialect=self.dialect, user=user, passwd=password, database=self.db)
database.add_messages(data)
def getUserRights():
token = request.query['token']
if not DatabaseManager.checkSession(token):
return HTTPResponse(status=401)
rights = DatabaseManager.getUserRights(
DatabaseManager.getLoginByToken(token)[0])[0]
return HTTPResponse(status=200, body=json.dumps({'rights': rights}))
def __init__(self, app):
QDialog.__init__(self)
self.app = app
self.app_path = os.getenv("APPDATA") + "\\" + qApp.applicationName()
self.registrySettings = QSettings("HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run", QSettings.NativeFormat)
self.table_path = self.app_path + "\\tables"
self.engine = Engine()
self.minimize_action = QAction("Minimize", self)
self.maximize_action = QAction("Maximize", self)
self.settings_action = QAction("Settings", self)
self.about_action = QAction("About", self)
self.quit_action = QAction("Quit", self)
self.tray_icon_menu = QMenu(self)
self.tray_icon = QSystemTrayIcon(self)
self.setupUi(self)
self.icon = QIcon(QPixmap(":icon/off_logo"))
self.construct_tray_icon()
self.signal_connectors()
self.database = DatabaseManager()
self.shortcut_key = self.database.get_shortcut_key()
self.populate_modifier_cbox()
if self.database.get_current_state() == "True":
self.engine.conv_state = False
else:
self.engine.conv_state = True
self.icon_activated(QSystemTrayIcon.Trigger)
self.file_path_tview.setEnabled(False)
self.check_app_path()
self.update_table(True)
self.init_combobox()
if self.registrySettings.contains(qApp.applicationName()):
self.start_windows_check.setChecked(True)
else:
self.start_windows_check.setChecked(False)
def getRoomRents():
token = request.query['token']
if not DatabaseManager.checkSession(token):
return HTTPResponse(status=401)
return HTTPResponse(
status=200,
body=json.dumps(DatabaseManager.getRoomRents(request.query['room'])))
def getUserRents():
token = request.query['token']
if not DatabaseManager.checkSession(token):
return HTTPResponse(status=401)
userId = DatabaseManager.getUserId(request.query['user'])
_body = json.dumps(DatabaseManager.getUserRents(userId[0]))
return HTTPResponse(status=200, body=_body)
def performance_info(uuid):
perf_info = {}
perf_ref = dbm.retrieve_perf_ref(uuid)
perf_info['record'] = perf_ref.elements
perf_info['linkedStates'] = dbm.retrieve_all_state_perf_links(uuid)
perf_info['availablePerformances'] = [dict(p.get_element_items()) for p in dbm.retrieve_derived_performances(perf_ref['game_uuid'])]
return jsonify(perf_info)
def backuper():
"""
Backs up each item in backup list.
"""
# start logging
logging.info('Starting backups')
# bring in the backups
db = DatabaseManager(BACKUP_FILE_PATH)
logging.debug('Database loaded')
sql = 'SELECT * FROM backups'
backup_list = db.select(sql, None)
# backup schema:
# [0]coordinate, [1]name, [2]owner, [3]active, [4]backup_times
for entry in backup_list:
# Is this planet being actively backed up?
if not entry[3]:
# nope, skip it
continue
# perform the backup action
perform_backup(db, entry)
# update log to reflect new backup
prune_backups(db, entry)
logging.info('Backups completed.')
logging.info('=====================================================.')
class get_dbm(object):
def __enter__(self):
self.dbm = DatabaseManager(config.DB_HOST, config.DB_USER, config.DB_PASSWORD, config.DB_NAME)
return self.dbm
def __exit__(self, type, value, traceback):
self.dbm.close()
def database_manager() -> DatabaseManager:
filename = "helpdesk.db"
dbm = DatabaseManager(filename)
yield dbm
dbm.__del__() # explicitly release the database manager
os.remove(filename)
def get_friends():
db_manager = DatabaseManager()
username = request.json.get('username')
token = request.json.get('token')
if username == None or token == None:
abort(400)
# Verifiy token
token_credentials = db_manager.verify_auth_token(token=token)
if token_credentials is None:
return json.dumps({'username': '******'})
elif not db_manager.check_password(token_credentials[0],
token_credentials[1]):
return json.dumps({'username': '******'})
elif token_credentials[0] != username:
abort(401)
friends = db_manager.get_friends_for_user(username)
# It is unsafe to send your friends password hash to the browser... email_verified and id aren't needed
for friend in friends:
del friend['password_hash']
del friend['email_verified']
del friend['id']
return json.dumps(friends)
def remember():
db_manager = DatabaseManager()
selector = request.json.get('selector')
if selector:
data = db_manager.get_auth_id(selector)
if data:
token = json.loads(data)['token']
return response_cache_header(json.dumps({
"token": token,
"success": True
}),
cache_control="no-cache")
else:
return response_cache_header(json.dumps({
"error": "no session",
"success": False
}),
cache_control="no-cache")
else:
return response_cache_header(json.dumps({
"error": "no session",
"success": False
}),
cache_control="no-cache")
def get_friends():
db_manager = DatabaseManager()
username = request.json.get("username").lower()
token = request.json.get("token")
if username == None or token == None:
abort(400)
# Verifiy token
token_credentials = db_manager.verify_auth_token(token=token)
if token_credentials is None:
abort(401)
elif not db_manager.check_password(token_credentials[0], token_credentials[1]):
abort(401)
elif token_credentials[0] != username:
abort(401)
friends = db_manager.get_friends_for_user(username)
# It is unsafe to send your friends password hash to the browser... email_verified and id aren't needed
for friend in friends:
if friend == None:
friends.remove(friend)
continue
del friend["password_hash"]
del friend["email_verified"]
del friend["id"]
return response_cache_header(json.dumps({"friends": friends}))
def get_friends():
db_manager = DatabaseManager()
username = request.json.get('username').lower()
token = request.json.get('token')
if username == None or token == None:
abort(400)
# Verifiy token
token_credentials = db_manager.verify_auth_token(token=token)
if token_credentials is None:
abort(401)
elif not db_manager.check_password(token_credentials[0],
token_credentials[1]):
abort(401)
elif token_credentials[0] != username:
abort(401)
friends = db_manager.get_friends_for_user(username)
# It is unsafe to send your friends password hash to the browser... email_verified and id aren't needed
for friend in friends:
if friend == None:
friends.remove(friend)
continue
del friend['password_hash']
del friend['email_verified']
del friend['id']
return response_cache_header(json.dumps({"friends": friends}))
def backuper():
"""
Backs up each item in backup list.
"""
# start logging
logging.info('Starting backups')
# bring in the backups
db = DatabaseManager(BACKUP_FILE_PATH)
logging.debug('Database loaded')
sql = 'SELECT * FROM backups'
backup_list = db.select(sql, None)
# backup schema:
# [0]coordinate, [1]name, [2]owner, [3]active, [4]backup_times
for entry in backup_list:
# Is this planet being actively backed up?
if not entry[3]:
# nope, skip it
continue
# perform the backup action
perform_backup(db, entry)
# update log to reflect new backup
prune_backups(db, entry)
logging.info('Backups completed.')
logging.info('=====================================================.')
def __init__(self):
super().__init__(command_prefix=custom_prefix,
owner_id=int(environ['OWNER_ID']),
case_insensitive=True,
help_command=None,
max_messages=None,
fetch_offline_members=platform.machine() != 'armv7l',
activity=Game(f'Loading...'))
self.db = DatabaseManager(name=environ['DATABASE_NAME'],
uri=environ['DATABASE_URI'],
bot=self)
self.i18n = i18n.I18N(source='pt_BR')
self.log = log
self.emoji = emojis
self.color = DEFAULT_EMBED_COLORS
self.loaded = False
self.launched_shards = []
self.started_at = datetime.utcnow()
self.wavelink = wavelink.Client(self)
self.guild_blacklist = set()
self.user_blacklist = set()
self.invoked_commands = 0
self.read_messages = 0
self.played_tracks = 0
self.prefixes = environ['PREFIXES'].split(', ')
self._prefixes = {}
self._message_logs = set()
def insert_or_update_in_db(self):
# if not self.isInDB:
sql = "INSERT INTO `TrackedTorrentFiles` (`hash`, `name`, `timeout`, `torrentHash`, `torrentFileName`) VALUES (%s, %s, UNIX_TIMESTAMP()+%s, %s, %s) ON DUPLICATE KEY UPDATE timeout=VALUES(timeout);"
DatabaseManager.Instance().cursor.execute(
sql, (self.hash, self.name, self.timeout, self.torrent_hash,
self.torrent_file_name))
DatabaseManager.Instance().connector.commit()
def add_rl_save_state_data(uuid):
rl_starts_b64 = request.form.get('rl_starts')
rl_lengths_b64 = request.form.get('rl_lengths')
rl_total_length = int(request.form.get('rl_total_length'))
rl_lengths_length = int(request.form.get('rl_lengths_length'))
rl_starts_length = int(request.form.get('rl_starts_length'))
rl_starts_b_array = bytearray(base64.b64decode(rl_starts_b64))
rl_lengths_b_array = bytearray(base64.b64decode(rl_lengths_b64))
if len(rl_starts_b_array) != rl_starts_length:
rl_starts_b_array.extend([0 for _ in range(len(rl_starts_b_array), rl_starts_length)])
if len(rl_lengths_b_array) != rl_lengths_length:
rl_lengths_b_array.extend([0 for _ in range(len(rl_lengths_b_array), rl_lengths_length)])
rl_start_hash, file_name = save_byte_array_to_store(rl_starts_b_array, file_name=uuid)
rl_lengths_hash, file_name = save_byte_array_to_store(rl_lengths_b_array, file_name=uuid)
dbm.update_table(dbm.GAME_SAVE_TABLE,
['rl_starts_data','rl_lengths_data','rl_total_length','compressed'],
[rl_start_hash, rl_lengths_hash, rl_total_length, True],
['uuid'], [uuid])
return jsonify({'record': dbm.retrieve_save_state(uuid=uuid)[0]})
class GameScraper:
"""
Pulls down play-by-play and schedule data from ESPN
"""
def __init__(self, game_ids, players, season=None, force_retrieval=False):
self.force_retrieval = force_retrieval
self.season = season
self.game_ids = game_ids
self.players = players
self.database_manager = DatabaseManager()
self.parser = PlayByPlayParser()
self.game_root_url = "http://www.espn.com/nba/playbyplay?gameId={0}"
def _save_pbp_to_disk(self, page, game_id):
import os
pbp_path = os.path.join('data', str(self.season))
with open(os.path.join(pbp_path, "pbp_" + str(game_id) + ".txt"),
"wb") as f:
f.write(str(page))
def scrape_pbp(self):
print self.season
stored_game_ids = np.unique([
dunk["game_id"]
for dunk in self.database_manager.get_dunks(self.season)
])
missing_game_ids = set(self.game_ids) - set(stored_game_ids)
print len(
missing_game_ids
), " missing game ids in dunk database, will attempt to retrieve."
pbp_path = os.path.join('data', str(self.season), 'pbp_reg')
for game_id in missing_game_ids:
try:
with open(
os.path.join(pbp_path, "pbp_" + str(game_id) + ".txt"),
"r") as f:
g = f.read()
print "We've got this on disk"
except IOError:
print "Don't have this play-by-play yet"
time.sleep(np.random.randint(2, 7))
try:
g = urllib2.urlopen(
self.game_root_url.format(game_id)).read()
self._save_pbp_to_disk(bs4.BeautifulSoup(g, "lxml"),
game_id)
except urllib2.URLError:
print "could not get page"
continue
dunks = self.parser.parse_pbp(g, self.players, game_id,
self.season)
if dunks is not None:
for dunk in dunks:
if dunk is not None:
self.database_manager.add_dunk(dunk)
else:
continue
def __init__(self, game_ids, players, season=None, force_retrieval=False):
self.force_retrieval = force_retrieval
self.season = season
self.game_ids = game_ids
self.players = players
self.database_manager = DatabaseManager()
self.parser = PlayByPlayParser()
self.game_root_url = "http://www.espn.com/nba/playbyplay?gameId={0}"
def random_course(request):
if not request.is_ajax():
print 'not ajax'
return
db = DatabaseManager()
course = db.generate_random_course()
jsonified = json.dumps(course, default=decimal_default)
return HttpResponse(jsonified)
def change_status(self):
self.engine.conv_state = not self.engine.conv_state
DatabaseManager.set_current_state(self.engine.conv_state)
if self.engine.conv_state:
self.show_on_status()
self.load_keyboard()
else:
self.show_off_status()
def make_performance_package(performance):
pack = {}
game = dbm.retrieve_game_ref(performance['game_uuid'])
pack['game'] = game.elements if game else None
pack['performance'] = performance.elements
# Last performance is current performance
pack['previous_performances'] = [i.elements for i in dbm.retrieve_performance_chain(performance['uuid'])[:-1]]
return pack
def change_status(self):
self.engine.conv_state = not self.engine.conv_state
DatabaseManager.set_current_state(self.engine.conv_state)
if self.engine.conv_state:
self.show_on_status()
self.load_keyboard()
else:
self.show_off_status()
def delete_script():
body = request.json
token = body['token']
if not DatabaseManager.check_session(token):
return HTTPResponse(status=401)
user_id = DatabaseManager.get_user_id(body['user'])
DatabaseManager.delete_script(user_id, body['name'])
return HTTPResponse(status=200)
def controllers():
token = request.query['token']
if not DatabaseManager.check_session(token):
return HTTPResponse(status=401)
user_id = DatabaseManager.get_user_id(request.query['user'])
result = DatabaseManager.get_user_controllers(user_id)
_response = {"controllers": [dict(x) for x in result]}
return HTTPResponse(status=200, body=json.dumps(_response))
def getHotelAvailableRooms():
token = request.query['token']
if not DatabaseManager.checkSession(token):
return HTTPResponse(status=401)
return HTTPResponse(status=200,
body=json.dumps(
DatabaseManager.getHotelAvailableRooms(
request.query['hotel'])))
def get_received_code():
token = request.query['token']
if not DatabaseManager.check_session(token):
return HTTPResponse(status=401)
key = request.query['key']
code = DatabaseManager.get_received_code(key)
_response = {'code': code}
return HTTPResponse(status=200, body=_response)
def database_manager() -> DatabaseManager:
filename = "test_additional.db"
dbm = DatabaseManager(filename)
yield dbm
dbm.__del__() # this is to release the database manager afterwards
os.remove(filename
) # this does what it sounds like it does, removes the test file
def citations_all_page():
all_game_cites = [dbm.create_cite_ref_from_db(GAME_CITE_REF, x) for x in dbm.retrieve_all_from_table(dbm.GAME_CITATION_TABLE)]
all_perf_cites = [dbm.create_cite_ref_from_db(PERF_CITE_REF, x) for x in dbm.retrieve_all_from_table(dbm.PERFORMANCE_CITATION_TABLE)]
return render_template('citations_main.html',
all_game_cites=all_game_cites,
all_perf_cites=all_perf_cites,
perf_headers=all_perf_cites[0].get_element_names() if all_perf_cites else [],
game_headers=all_game_cites[0].get_element_names() if all_game_cites else [])
def citation_add(cite_type):
clean_params = dict([(k, v) for k, v in request.form.items() if not v or v != 'None'])
if cite_type == GAME_CITE_REF:
cite = generate_cite_ref(GAME_CITE_REF, GAME_SCHEMA_VERSION, **clean_params)
elif cite_type == PERF_CITE_REF:
cite = generate_cite_ref(PERF_CITE_REF, PERF_SCHEMA_VERSION, **clean_params)
dbm.add_to_citation_table(cite, fts=True)
return redirect(url_for('citation_page', uuid=cite['uuid']))
def set_timeout(self, timeout=2538000):
# default timeout set to 30 days
sql = "UPDATE `TrackedTorrentFiles` SET `timeout`=UNIX_TIMESTAMP()+ %d WHERE `name`=%s;"
DatabaseManager.Instance().cursor.execute(sql, (
timeout,
self.name,
))
DatabaseManager.Instance().connector.commit()
def accept_friend(token):
db_manager = DatabaseManager()
names = confirm_token(token)
if db_manager.users_are_friends(names[0], names[1]):
return response_cache_header("Already friends", cache_control="no-cache")
else:
db_manager.create_friendship(names[0], names[1])
return response_cache_header("Now friends", cache_control="no-cache")
def accept_friend(token): db_manager = DatabaseManager() names = confirm_token(token) if db_manager.users_are_friends(names[0], names[1]): return "Already friends" else: db_manager.create_friendship(names[0], names[1]) return "Now friends"
def verify_email(token): db_manager = DatabaseManager() email = confirm_token(token) if db_manager.email_is_verified(email): return "Email already verified.\n" else: # Verify db_manager.verify_email(email) return "Email Successfully verified.\n"
def verify_email(token):
db_manager = DatabaseManager()
email = confirm_token(token)
if db_manager.email_is_verified(email):
return response_cache_header("Email already verified.\n", cache_control="no-cache")
else:
# Verify
db_manager.verify_email(email)
return response_cache_header("Email Successfully verified.\n", cache_control="no-cache")
def ok_file(self, button, filesel):
path = filesel.get_filename()
mdpath = join(dirname(path), 'machine_database.xml')
action = filesel.get_data('action')
filesel.destroy()
dir = dirname(path)
dbm = DatabaseManager(self.conn)
if action == 'backup':
dbm.backup(dir)
elif action == 'restore':
dbm.restore(dir)
def init_combobox(self):
self.keyboard_cbox.blockSignals(True)
self.keyboard_cbox.clear()
current_keyboard = DatabaseManager.get_current_keyboard()
index = 0
for keyboard in DatabaseManager.get_all_keyboards()[1]:
self.keyboard_cbox.addItem(keyboard.language_name, keyboard.id)
if int(current_keyboard) == keyboard.id:
self.keyboard_cbox.setCurrentText(keyboard.language_name)
self.keyboard_cbox.setCurrentIndex(index)
index += 1
self.keyboard_cbox.blockSignals(False)
def add_screen_data(uuid):
screen_data = bytes(base64.b64decode(request.form.get('buffer')))
width = int(request.form.get('width'))
height = int(request.form.get('height'))
image = Image.frombytes("RGBA", (width, height), screen_data)
# Doing the saving here for now, might move later?
base_path = os.path.join(LOCAL_CITATION_DATA_STORE, uuid)
if not os.path.exists(base_path):
os.makedirs(base_path)
image.save(os.path.join(base_path, 'screen_{}.png'.format(uuid)), "PNG")
dbm.add_screen_to_state(uuid) # one screen per state, so only change 'has_screen' parameter
state = dbm.retrieve_save_state(uuid=uuid)[0]
return jsonify({'record': state})
def store():
db_manager = DatabaseManager()
token = request.json.get("token")
# password = sha512_crypt.encrypt(request.json.get('password'), salt=app.config['SECURITY_PASSWORD_SALT'], rounds=5000)
selector = request.json.get("selector")
if selector:
db_manager.add_auth_token(selector, token)
return response_cache_header(
json.dumps({"response": "Stored session", "success": True}), cache_control="no-cache"
)
else:
return response_cache_header(json.dumps({"error": "Not satisfied", "success": False}), cache_control="no-cache")
def remove():
db_manager = DatabaseManager()
selector = request.json.get("selector")
if selector:
db_manager.remove_auth_token(selector)
return response_cache_header(
json.dumps({"response": "Removed Session", "success": True}), cache_control="no-cache"
)
else:
return response_cache_header(
json.dumps({"response": "Did not remove session", "success": False}), cache_control="no-cache"
)
def search_globally_with_game_partial(citation_partial):
citations = []
NEW = 'new'
OLD = 'old'
@coroutine
def process_citation_url():
while True:
url = (yield)
if not dbm.is_attr_in_db('source_url', url, dbm.GAME_CITATION_TABLE):
click.echo('Extracting url {} through coroutine.'.format(url))
extractor = get_extractor_for_uri(url, get_url_source(url))
extractor.extract()
citation, extracted_options = extractor.create_citation()
citations.append((citation, NEW))
else:
click.echo('Found {} in local db.'.format(url))
citation = dbm.create_cite_ref_from_db(GAME_CITE_REF,
dbm.retrieve_attr_from_db(
'source_url',
url,
dbm.GAME_CITATION_TABLE)[0])
citations.append((citation, OLD))
# Currently this search is only through MobyGames, may work on federated search
# in the future. Also only searches on title for now
# Just need the extractor, don't need its state
search_string = citation_partial['description']['title']
limit = citation_partial['limit'] if 'limit' in citation_partial else None
search_uris = get_extractor_for_uri('http://www.mobygames.com', None).get_search_uris(search_string)
if limit and limit <= len(search_uris) - 1:
search_uris = search_uris[:limit]
# Process coroutine
# Send uris to coroutine generator
for uri in search_uris:
process_citation_url().send(uri)
# Block until all the search citations return
while len(citations) != len(search_uris):
pass
for c in citations:
if c[1] == NEW:
dbm.add_to_citation_table(c[0], fts=True)
return [c for c, _ in citations]
def show_user_list(username, listname):
db_manager = DatabaseManager()
token = request.json.get("token")
if token is None or token is "":
return json.dumps({ 'username':'******' })
# Verifiy token
token_credentials = db_manager.verify_auth_token(token=token)
if token_credentials is None:
return json.dumps({ 'username':'******' })
elif not db_manager.check_password(token_credentials[0], token_credentials[1]):
return json.dumps({ 'username':'******'})
if db_manager.username_exists(username):
if db_manager.listname_exists_for_user(username, listname):
list_data = db_manager.get_list(username, listname)
shared_with = list_data.get("shared_with")
translations = db_manager.get_translations_for_list(username, listname)
for translation in translations: del translation['id']; del translation['list_id']
# Check if is owner
if username == token_credentials[0]:
return json.dumps({
'listname' : listname,
'language_1_tag' : list_data.get("language_1_tag"),
'language_2_tag' : list_data.get("language_2_tag"),
'words' : translations,
'shared_with' : shared_with
})
# Check if is friend
elif shared_with == '1' and db_manager.users_are_friends(username, token_credentials[0]):
return json.dumps({
'listname' : listname,
'language_1_tag' : list_data.get("language_1_tag"),
'language_2_tag' : list_data.get("language_2_tag"),
'words' : translations,
'shared_with' : shared_with
})
elif shared_with == '2':
return json.dumps({
'listname' : listname,
'language_1_tag' : list_data.get("language_1_tag"),
'language_2_tag' : list_data.get("language_2_tag"),
'words' : translations,
'shared_with' : shared_with
})
else:
abort(401)
else:
return json.dumps({
'username': '******'t happen'
})
else:
return json.dumps({
'username': '******'t happen'
})
def search_locally_with_partial(partial, exclude_ref_types=None):
start_index = int(partial['start_index'])
limit = int(partial['limit']) if 'limit' in partial else None
# Apparently Python DB API and Sqlite and commas (,), parans ((,)), and colons (:) do not play nice with FTS?
search_strings = u" ".join([unicode(v) for k, v in partial['description'].items()])
for ref_type in exclude_ref_types:
search_strings += u" AND NOT (tags:{})".format(ref_type)
uuids = dbm.retrieve_from_fts(search_strings, start_index=start_index, limit=limit)
def get_cite_for_uuid(result):
ref_type = result['tags']
uuid = result['uuid']
if ref_type == GAME_CITE_REF:
table = dbm.GAME_CITATION_TABLE
if ref_type == PERF_CITE_REF:
table = dbm.PERFORMANCE_CITATION_TABLE
if ref_type == STATE_CITE_REF:
table = dbm.GAME_SAVE_TABLE
if ref_type in (GAME_CITE_REF, PERF_CITE_REF):
db_values = dbm.retrieve_attr_from_db('uuid', uuid, table, limit=1)[0]
citation = dbm.create_cite_ref_from_db(ref_type, db_values)
else:
citation = dbm.retrieve_save_state(uuid=uuid)[0]
citation['ref_type'] = STATE_CITE_REF
return citation
# Results should already be sorted by rank
citations = map(get_cite_for_uuid, uuids)
return citations
def __init__(self):
QDialog.__init__(self)
self.app_path = os.getenv("APPDATA") + "\\" + qApp.applicationName()
self.registrySettings = QSettings("HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run", QSettings.NativeFormat)
self.table_path = self.app_path + "\\tables"
self.engine = Engine()
self.minimize_action = QAction("Minimize", self)
self.maximize_action = QAction("Maximize", self)
self.settings_action = QAction("Settings", self)
self.about_action = QAction("About", self)
self.quit_action = QAction("Quit", self)
self.tray_icon_menu = QMenu(self)
self.tray_icon = QSystemTrayIcon(self)
self.setupUi(self)
self.icon = QIcon(QPixmap(":icon/off_logo"))
self.construct_tray_icon()
self.signal_connectors()
self.database = DatabaseManager()
self.shortcut_key = self.database.get_shortcut_key()
self.populate_modifier_cbox()
if self.database.get_current_state() == "True":
self.engine.conv_state = False
else:
self.engine.conv_state = True
self.icon_activated(QSystemTrayIcon.Trigger)
self.file_path_tview.setEnabled(False)
self.check_app_path()
self.update_table(True)
self.init_combobox()
if self.registrySettings.contains(qApp.applicationName()):
self.start_windows_check.setChecked(True)
else:
self.start_windows_check.setChecked(False)
def __init__(self, config):
config.events.StartInitSession()
# init alpm
if p.alpm_initialize() == -1:
raise SessionError("Could not initialize session (alpm_initialize)")
self.config = config
p.alpm_option_set_root(config.rootpath)
p.alpm_option_set_arch(config.architecture)
# set up and register databases
if p.alpm_option_set_dbpath(config.local_db_path) == -1:
raise SessionError("Could not open the database path: %s" % \
config.local_db_path)
self.db_man = DatabaseManager(config.events)
self.db_man.register("local", LocalDatabase())
for repo, url in config.available_repositories.items():
self.db_man.register(repo, SyncDatabase(repo, url))
if config.aur_support:
self.db_man.register("aur", AURDatabase(config))
self.apply_config()
self.config.events.DoneInitSession()
def update_save_state(uuid):
update_fields = json.loads(request.form.get('update_fields'))
# if linking to a performance, do that and then throw away since GAME_SAVE_TABLE doesn't refer to performance
if 'performance_uuid' in update_fields:
performance_uuid = update_fields['performance_uuid']
performance_time_index = update_fields['performance_time_index']
action = update_fields['action']
dbm.link_save_state_to_performance(uuid, performance_uuid, performance_time_index, action)
del update_fields['performance_uuid']
del update_fields['performance_time_index']
del update_fields['action']
# make sure that there are still fields to update
if len(update_fields.keys()) > 0:
dbm.update_table(dbm.GAME_SAVE_TABLE, update_fields.keys(),update_fields.values(), ['uuid'], [uuid])
return jsonify(dbm.retrieve_save_state(uuid=uuid)[0])
def add_save_state_data(uuid):
save_state_data = request.form.get('buffer')
compressed = True if request.form.get('compressed') == u'true' else False
data_length = int(request.form.get('data_length'))
save_state_b_array = bytearray(base64.b64decode(save_state_data))
# The base64 library will interpret trailing zeros as padding and remove them, this adds them back in
if len(save_state_b_array) != data_length:
save_state_b_array.extend([0 for _ in range(len(save_state_b_array), data_length)])
source_data_hash, file_name = save_byte_array_to_store(save_state_b_array, file_name=uuid)
dbm.update_table(dbm.GAME_SAVE_TABLE,
['save_state_source_data', 'compressed'],
[source_data_hash, compressed],
['uuid'], [uuid])
return jsonify({'record': dbm.retrieve_save_state(uuid=uuid)[0]})
