def start_app() -> Tuple[Flask, Dict[str, int]]:
# APP SETUP
app = Flask(__name__,
template_folder=os.path.join('frontend', 'templates'),
static_folder=os.path.join('frontend', 'static'),
static_url_path='/static2')
set_up_app_config(app)
CORS(app)
create_needed_folders(app)
engine, Session = startup()
with app.app_context():
register_blueprints(app)
try:
import config
app.secret_key = config.SECRET_KEY
except: # TODO: Specify necessary excepts here.
logger.warning('No secret key has been set')
app.config['db'] = Session
app.config['r'] = get_redis()
_session = Session()
groups_to_add = ['admin', 'alpha', 'beta']
add_needed_groups_to_db(_session, groups_to_add)
ids, ids_to_group = get_id_group_dicts(_session, groups_to_add)
app.config['groups'] = ids_to_group
_session.commit()
_session.close()
create_jinja_globals(app, g)
return app, ids
def setUp(self):
self.tag_name_alt = TAGS[1]
self.all_tags = TAGS
self.test_user_id = TEST_USER_ID
engine, Session = startup()
self.session = Session()
self.test_game_id = TEST_GAME_ID
self.test_game_ids = self.create_replay_names()
test_user = self.session.query(Player).filter(Player.platformid == self.test_user_id).first()
if test_user is None:
test_user = Player(platformid=self.test_user_id)
self.session.add(test_user)
for i in range(len(self.test_game_ids)):
tag_name = self.all_tags[i]
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == tag_name).first()
if tag is None:
tag = Tag(owner=self.test_user_id, name=tag_name)
self.session.add(tag)
for game_id in self.test_game_ids:
game = self.session.query(Game).filter(Game.hash == game_id).first()
if game is None:
game = Game(hash=game_id)
self.session.add(game)
self.session.commit()
# add some spice to the games :>
for i in range(len(self.test_game_ids)):
game_id = self.test_game_ids[i]
for j in range(len(self.test_game_ids) - i):
TagWrapper.add_tag_to_game(self.session, game_id, self.test_user_id, self.all_tags[j])
def setUp(self):
engine, sessionmaker = startup.startup()
self.session = sessionmaker()
_, path = tempfile.mkstemp()
with open(path, 'wb') as tmp:
tmp.write(download_replay_discord(get_complex_replay_list()[0]))
self.replay = analyze_replay_file(path, path + '.json')
self.proto = self.replay.protobuf_game
self.guid = self.proto.game_metadata.match_guid
def get_bot_by_steam_id(steam_id):
if steam_id[0] == 'b' and steam_id[-1] == 'b':
if len(steam_id) < 6:
return "Allstar"
else:
engine, Session = startup()
bot = Session().query(Player).filter(
Player.platformid == steam_id).first()
if bot is None:
return None
return bot.platformname
return None
def setUp(self):
self.tag_name = TAGS[0]
self.test_user_id = TEST_USER_ID
engine, Session = startup()
self.session = Session()
test_user = self.session.query(Player).filter(Player.platformid == self.test_user_id).first()
if test_user is None:
test_user = Player(platformid=self.test_user_id)
self.session.add(test_user)
self.session.commit()
def setUp(self):
self.tag_name = TAGS[0]
self.tag_name_alt = TAGS[1]
self.test_user_id = TEST_USER_ID
engine, Session = startup()
self.session = Session()
self.test_game_id = TEST_GAME_ID
test_user = self.session.query(Player).filter(Player.platformid == self.test_user_id).first()
if test_user is None:
test_user = Player(platformid=self.test_user_id)
self.session.add(test_user)
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == self.tag_name).first()
if tag is None:
tag = Tag(owner=self.test_user_id, name=self.tag_name)
self.session.add(tag)
game = self.session.query(Game).filter(Game.hash == self.test_game_id).first()
if game is None:
game = Game(hash=self.test_game_id)
self.session.add(game)
self.session.commit()
import glob
import os
import sys
sys.path.append(os.path.abspath('.'))
from backend.database.startup import startup
def main(sess):
s = sess()
s.execute('DROP TABLE GAMES CASCADE;')
s.execute('DROP TABLE PLAYERGAMES CASCADE;')
s.commit()
s.close()
if __name__ == '__main__':
engine, Session = startup()
main(Session)
model_holder = RankPredictor()
class RankPredictionAPI:
@staticmethod
@with_session
def create_from_id(id_, session=None):
game: Game = session.query(Game).filter(Game.hash == id_).first()
if game.playlist != 13 and game.playlist != 3 and game.playlist != 6: # standard and unranked standard and customs
return {}
playergames = session.query(PlayerGame).filter(
PlayerGame.game == id_).all()
ranks = {}
for pg in playergames:
ranks[pg.player] = model_holder.predict_rank(pg)
return ranks
if __name__ == '__main__':
from backend.database.startup import startup
pr = RankPredictor()
engine, sessionmaker = startup()
s = sessionmaker()
for o in s.query(PlayerGame)[:20]:
print(o.name, o.rank)
print(pr.predict_rank(o))
s.close()
def session(self):
if self._session is None:
_, self._session = startup()
return self._session
def initialize_db():
engine, sessionmaker = startup.startup()
session = sessionmaker()
_, path = tempfile.mkstemp()
return session
import os
import pickle
import traceback
from concurrent.futures import ThreadPoolExecutor
from functools import partial
import redis
from sqlalchemy.engine import Engine
from sqlalchemy.orm import sessionmaker, Session
from backend.database.objects import Game
from backend.database.startup import startup
from backend.database.utils.utils import convert_pickle_to_db, add_objs_to_db
logger = logging.getLogger(__name__)
engine, Session = startup() # type: (Engine, sessionmaker)
r = redis.Redis(
host='localhost',
port=6379)
pickled_location = os.path.join(os.path.dirname(__file__), '..', 'data', 'parsed')
pickles = glob.glob(os.path.join(pickled_location, '*.pkl'))
s = Session()
games = s.query(Game.hash).all()
def main():
with ThreadPoolExecutor() as executor:
fn = partial(parse_pickle)
executor.map(fn, pickles, timeout=120)