def setUp(self): self.tag_name_alt = TAGS[1] self.all_tags = TAGS self.test_user_id = TEST_USER_ID session = lazy_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_by_name_to_game(self.session, game_id, self.test_user_id, self.all_tags[j])
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: session = lazy_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 session = lazy_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 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') CalculatedServer.set_up_app_config(app) CORS(app) CalculatedServer.create_needed_folders(app) # Enable GZIP compression Compress(app) session_factory = lazy_startup() with app.app_context(): create_celery_config() CalculatedServer.register_blueprints(app) CalculatedServer.setup_metrics(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_factory app.config['r'] = lazy_get_redis() _session = session_factory() CalculatedServer.add_needed_groups_to_db(_session, SERVER_PERMISSION_GROUPS) ids, ids_to_group = CalculatedServer.get_id_group_dicts( _session, SERVER_PERMISSION_GROUPS) app.config['groups'] = ids_to_group _session.commit() _session.close() return app, ids
def setUp(self): self.tag_name = TAGS[0] self.tag_name_alt = TAGS[1] self.test_user_id = TEST_USER_ID session = lazy_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()
date_end=None, session=None): if session is None: sess = self.session() else: sess = session start = time.time() url = TrainingPackCreation.create_from_player(id_, n, date_start, date_end, sess) end = time.time() METRICS_TRAINING_PACK_CREATION_TIME.observe(start - end) return url class ResultState(Enum): PENDING = auto() STARTED = auto() RETRY = auto() FAILURE = auto() SUCCESS = auto() def get_task_state(id_) -> ResultState: # NB: State will be PENDING for unknown ids. return ResultState[AsyncResult(id_, app=celery).state] if __name__ == '__main__': sess = lazy_startup() calc_item_stats(None, session=sess())
def initialize_db(): sessionmaker = startup.lazy_startup() session = sessionmaker() return session
import glob import os import datetime from backend.database.objects import Game from backend.database.startup import lazy_startup from backend.tasks.celery_tasks import parse_replay_task_low_priority import json def main(s): sess = s() games = sess.query(Game.hash).all() with open(datetime.datetime.now().strftime('%H-%m-%s') + '.json', 'w') as f: json.dump(list(games), f) games = glob.glob( os.path.abspath(os.path.join('..', 'data', 'rlreplays', '*.replay'))) for game in games: # path = os.path.abspath(os.path.join('..', 'data', 'rlreplays', game + '.replay')) # if os.path.isfile(path): # parse_replay_task_low_priority.delay(path) # print('Delayed ' + game) if os.path.isfile(game): parse_replay_task_low_priority.delay(game) print('Delayed ' + game) if __name__ == '__main__': session = lazy_startup() main(Session)
import glob import logging import os import pickle import traceback from concurrent.futures import ThreadPoolExecutor from functools import partial from sqlalchemy.orm import sessionmaker, Session from backend.database.objects import Game from backend.database.startup import lazy_startup, lazy_get_redis from backend.database.utils.utils import convert_pickle_to_db, add_objs_to_db logger = logging.getLogger(__name__) session = lazy_startup() # type: sessionmaker r = lazy_get_redis() 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)
500, "Global stats unavailable or have not been calculated yet.") else: query_filter.clean().with_replay_ids(ids) return (query_filter.with_stat_query(stats_query).build_query( session).first(), query_filter.with_stat_query( stds_query).build_query(session).first()) @staticmethod def get_timeframe(): """Returns the number of days we accept old stats""" try: from flask import current_app return current_app.config['STAT_DAY_LIMIT'] except: return 30 if __name__ == '__main__': from backend.database.startup import lazy_startup session_factory = lazy_startup() sess = session_factory() try: result = GlobalStatWrapper().get_global_stats(sess) print(result) except KeyboardInterrupt: sess.close() finally: # result = engine.execute() sess.close()
def session(self): if self._session is None: self._session = lazy_startup() return self._session