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
