con = None

def __init__(self, database):

self.con = lite.connect(database=database, check_same_thread=False)

self._create_all_tables()

def __del__(self):

if self.con:

self.con.close()

def _create_all_tables(self):

cur = self.con.cursor()

cur.execute("""CREATE TABLE IF NOT EXISTS players (player_id INTEGER PRIMARY KEY AUTOINCREMENT,

name TEXT, photo TEXT,

player_stats_id INT, attack_stats_id INT, defense_stats_id INT)""")

cur.execute("CREATE TABLE IF NOT EXISTS teams (team_id INTEGER PRIMARY KEY AUTOINCREMENT, defense_player_id INT, attack_player_id INT, team_stats_id INT)")

cur.execute("CREATE TABLE IF NOT EXISTS games (game_id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp TEXT, left_team_id INT, right_team_id INT, left_score INT, right_score INT, ended INT)")

cur.execute("""CREATE TABLE IF NOT EXISTS stats (stats_id INTEGER PRIMARY KEY AUTOINCREMENT,

player_id INT, attack_player_id INT, defense_player_id INT, team_id INT,

wins INT, draws INT, losses INT,

goals_pro INT, goals_against INT,

elo_rating NUMBER,

timestamp TEXT)

""")

cur.execute("""CREATE TABLE IF NOT EXISTS hidden_players (player_id INTEGER)""")

self.con.commit()

def get_visible_players(self):

return self.get_hidden_players(hidden=False)

def get_hidden_players(self, hidden=True):

cur = self.con.cursor()

sql = """SELECT player_id, name, photo, player_stats_id, attack_stats_id, defense_stats_id FROM players

WHERE player_id {} in (SELECT player_id from hidden_players)""".format("not" if not hidden else "")

cur.execute(sql)

all_players = list(cur.fetchall())

return [Player(player_id=player_id, name=name, photo=photo, player_stats=self.get_stats(player_stats_id), attack_stats=self.get_stats(attack_stats_id), defense_stats=self.get_stats(defense_stats_id))

for player_id, name, photo, player_stats_id, attack_stats_id, defense_stats_id in all_players]

def hide_player(self, player_name, hidden):

player = self.get_player_by_name(name=player_name)

cur = self.con.cursor()

cur.execute("SELECT player_id FROM hidden_players WHERE player_id = :player_id", dict(player_id=player.player_id))

player_exists = cur.fetchone()

if player_exists and not hidden:

cur.execute("DELETE FROM hidden_players WHERE player_id = :player_id", dict(player_id=player.player_id))

elif not player_exists and hidden:

cur.execute("INSERT INTO hidden_players(player_id) VALUES(:player_id)", dict(player_id=player.player_id))

self.con.commit()

def get_player_by_name(self, name):

cur = self.con.cursor()

player_dict = dict(name=name)

cur.execute("SELECT player_id, name, photo, player_stats_id, attack_stats_id, defense_stats_id FROM players WHERE name LIKE :name", player_dict)

player_exists = cur.fetchone()

if player_exists:

player_id, _, photo, player_stats_id, attack_stats_id, defense_stats_id = player_exists

return Player(player_id=player_id, name=name, photo=photo, player_stats=self.get_stats(player_stats_id), attack_stats=self.get_stats(attack_stats_id), defense_stats=self.get_stats(defense_stats_id))

else:

return None

def get_player(self, player_id):

cur = self.con.cursor()

cur.execute("SELECT player_id, name, photo, player_stats_id, attack_stats_id, defense_stats_id FROM players WHERE player_id = :player_id", dict(player_id=player_id))

player_exists = cur.fetchone()

if player_exists:

player_id, name, photo, player_stats_id, attack_stats_id, defense_stats_id = player_exists

return Player(player_id=player_id, name=name, photo=photo, player_stats=self.get_stats(player_stats_id), attack_stats=self.get_stats(attack_stats_id), defense_stats=self.get_stats(defense_stats_id))

else:

return None

def get_all_players(self):

cur = self.con.cursor()

cur.execute("SELECT player_id, name, photo, player_stats_id, attack_stats_id, defense_stats_id FROM players")

all_players = list(cur.fetchall())

return [Player(player_id=player_id, name=name, photo=photo, player_stats=self.get_stats(player_stats_id), attack_stats=self.get_stats(attack_stats_id), defense_stats=self.get_stats(defense_stats_id))

for player_id, name, photo, player_stats_id, attack_stats_id, defense_stats_id in all_players]

def create_player(self, name, photo):

cur = self.con.cursor()

if self.get_player_by_name(name=name):

return None

else:

player_dict = dict(name=name, photo=photo)

cur.execute("INSERT INTO players(name, photo) VALUES(:name, :photo)", player_dict)

self.con.commit()

player_id = cur.lastrowid

player_stats = self.add_first_stats(player_id=player_id)

attack_stats = self.add_first_stats(attack_player_id=player_id)

defense_stats = self.add_first_stats(defense_player_id=player_id)

self.update_player_stats(player_id=player_id,

player_stats_id=player_stats.stats_id,

attack_stats_id=attack_stats.stats_id,

defense_stats_id=defense_stats.stats_id)

return Player(player_id=player_id, name=name, photo=photo, player_stats=player_stats, attack_stats=attack_stats, defense_stats=defense_stats)

def update_player_stats(self, player_id, player_stats_id, attack_stats_id, defense_stats_id):

cur = self.con.cursor()

cur.execute("UPDATE players SET player_stats_id = :player_stats_id, attack_stats_id = :attack_stats_id, defense_stats_id = :defense_stats_id WHERE player_id = :player_id",

dict(player_id=player_id, player_stats_id=player_stats_id, attack_stats_id=attack_stats_id, defense_stats_id=defense_stats_id))

self.con.commit()

def edit_player(self, player_name, new_player_name, new_player_photo):

cur = self.con.cursor()

player = self.get_player_by_name(name=player_name)

if not player:

return None

else:

player_dict = dict(name=new_player_name, photo=new_player_photo, player_id=player.player_id)

cur.execute("UPDATE players SET name = :name, photo = :photo WHERE player_id = :player_id", player_dict)

self.con.commit()

player.name = new_player_name

player.photo = new_player_photo

return player

def edit_player(self, player_name, new_player_name, new_player_photo):

cur = self.con.cursor()

player = self.get_player_by_name(name=player_name)

if not player:

return None

else:

player_dict = dict(name=new_player_name, photo=new_player_photo, player_id=player.player_id)

cur.execute("UPDATE players SET name = :name, photo = :photo WHERE player_id = :player_id", player_dict)

self.con.commit()

player.name = new_player_name

player.photo = new_player_photo

return player

def get_all_teams(self):

cur = self.con.cursor()

cur.execute("SELECT team_id, defense_player_id, attack_player_id, team_stats_id FROM teams")

self.con.commit()

all_teams = list(cur.fetchall())

return [Team(team_id=team_id,

defense_player=self.get_player(player_id=defense_player_id),

attack_player=self.get_player(player_id=attack_player_id),

team_stats=self.get_stats(team_stats_id))

for team_id, defense_player_id, attack_player_id, team_stats_id in all_teams]

def get_team(self, team_id):

cur = self.con.cursor()

cur.execute("SELECT team_id, defense_player_id, attack_player_id, team_stats_id FROM teams WHERE team_id = :team_id",

dict(team_id=team_id))

team_exists = cur.fetchone()

if team_exists:

team_id, defense_player_id, attack_player_id, team_stats_id = team_exists

return Team(team_id=team_id,

defense_player=self.get_player(player_id=defense_player_id),

attack_player=self.get_player(player_id=attack_player_id),

team_stats=self.get_stats(team_stats_id))

else:

return None

def create_team(self, defense_player, attack_player):

cur = self.con.cursor()

team_dict = dict(defense_player=defense_player, attack_player=attack_player)

team_dict_sql = dict(defense_player_id=defense_player.player_id, attack_player_id=attack_player.player_id)

cur.execute(

"SELECT team_id, defense_player_id, attack_player_id, team_stats_id FROM teams WHERE defense_player_id=:defense_player_id AND attack_player_id=:attack_player_id", team_dict_sql)

team_exists = cur.fetchone()

if team_exists:

team_id, _, _, team_stats_id = team_exists

return Team(team_id=team_id, team_stats=self.get_stats(team_stats_id), **team_dict)

else:

cur.execute("INSERT INTO teams(defense_player_id, attack_player_id) VALUES(:defense_player_id, :attack_player_id)",

team_dict_sql)

self.con.commit()

team_id = cur.lastrowid

team_stats = self.add_first_stats(team_id=team_id)

self.update_team_stats(team_id=team_id, team_stats_id=team_stats.stats_id)

return Team(team_id=team_id, team_stats=team_stats, **team_dict)

def update_team_stats(self, team_id, team_stats_id):

cur = self.con.cursor()

cur.execute("UPDATE teams SET team_stats_id = :team_stats_id WHERE team_id = :team_id",

dict(team_id=team_id, team_stats_id=team_stats_id))

self.con.commit()

def get_all_games(self):

cur = self.con.cursor()

cur.execute(

"SELECT game_id, timestamp, left_team_id, right_team_id, left_score, right_score, ended FROM games ORDER BY TIMESTAMP DESC")

all_games = list(cur.fetchall())

return [Game(game_id=game_id, timestamp=timestamp,

left_team=self.get_team(left_team_id), right_team=self.get_team(right_team_id),

left_score=left_score, right_score=right_score, ended=ended)

for game_id, timestamp, left_team_id, right_team_id, left_score, right_score, ended in all_games]

def delete_game_by_timestamp(self, timestamp):

cur = self.con.cursor()

cur.execute("DELETE FROM games WHERE timestamp=:timestamp", dict(timestamp=timestamp))

self.con.commit()

self.recalculate_stats()

def get_game_by_timestamp(self, timestamp):

cur = self.con.cursor()

cur.execute("SELECT game_id, timestamp, left_team_id, right_team_id, left_score, right_score, ended " +

"FROM games WHERE timestamp=:timestamp", dict(timestamp=timestamp))

game_exists = cur.fetchone()

if game_exists:

game_id, _, left_team_id, right_team_id, left_score, right_score, ended = game_exists

game = Game(game_id=game_id, timestamp=timestamp,

left_team=self.get_team(left_team_id), right_team=self.get_team(right_team_id),

left_score=left_score, right_score=right_score, ended=ended)

if game.game_should_end():

self.end_game(game)

return game

else:

return None

def create_update_game(self, timestamp, left_team, right_team, left_score=0, right_score=0, ended=0):

cur = self.con.cursor()

# todo: check some sort of upsert

game_dict = dict(timestamp=timestamp, left_team=left_team, right_team=right_team,

left_score=left_score, right_score=right_score, ended=ended)

game_dict_sql = dict(timestamp=timestamp, left_team_id=left_team.team_id, right_team_id=right_team.team_id,

left_score=left_score, right_score=right_score, ended=ended)

previous_game = self.get_game_by_timestamp(timestamp=timestamp)

if previous_game:

cur.execute("UPDATE games SET timestamp = :timestamp, left_team_id = :left_team_id, right_team_id = :right_team_id, " +

"left_score = :left_score, right_score = :right_score, ended = :ended " +

"WHERE game_id = :game_id",

dict(game_id=previous_game.game_id, **game_dict_sql))

self.con.commit()

game_id = previous_game.game_id

else:

self.end_all_opened_games()

cur.execute("INSERT INTO games(timestamp, left_team_id, right_team_id, left_score, right_score, ended) " +

"VALUES(:timestamp, :left_team_id, :right_team_id, :left_score, :right_score, :ended)", game_dict_sql)

self.con.commit()

game_id = cur.lastrowid

return Game(game_id=game_id, **game_dict)

def end_all_opened_games(self):

cur = self.con.cursor()

cur.execute("SELECT game_id, timestamp, left_team_id, right_team_id, left_score, right_score, ended " +

"FROM games WHERE ended=:ended", dict(ended=0))

open_games = list(cur.fetchall())

for (game_id, timestamp, _, _, left_score, right_score, ended) in open_games:

cur.execute("UPDATE games SET ended = :ended WHERE game_id = :game_id",

dict(game_id=game_id, ended=1))

self.con.commit()

def _end_games_that_shouldnt_be_open(self):

cur = self.con.cursor()

cur.execute("SELECT game_id, timestamp, left_team_id, right_team_id, left_score, right_score, ended " +

"FROM games WHERE ended=:ended", dict(ended=0))

open_games = list(cur.fetchall())

for (game_id, timestamp, _, _, left_score, right_score, ended) in open_games:

game = Game(game_id=game_id, left_team=None, right_team=None, timestamp=timestamp, left_score=left_score,

right_score=right_score, ended=ended)

if game.game_should_end():

self.end_game(game)

def get_open_game(self):

self._end_games_that_shouldnt_be_open()

cur = self.con.cursor()

cur.execute("SELECT game_id, timestamp, left_team_id, right_team_id, left_score, right_score, ended " +

"FROM games WHERE ended=:ended ORDER BY game_id desc", dict(ended=0))

open_game = cur.fetchone()

if open_game:

game_id, timestamp, left_team_id, right_team_id, left_score, right_score, ended = open_game

return Game(game_id=game_id, timestamp=timestamp,

left_team=self.get_team(left_team_id), right_team=self.get_team(right_team_id),

left_score=left_score, right_score=right_score, ended=ended)

else:

return None

def goal(self, side, value=1):

open_game = self.get_open_game()

open_game.goal_scored(side=side, value=value)

cur = self.con.cursor()

cur.execute("UPDATE games SET left_score = :left_score, right_score = :right_score, ended = :ended " +

"WHERE game_id = :game_id",

dict(game_id=open_game.game_id,

left_score=open_game.left_score,

right_score=open_game.right_score,

ended=open_game.ended))

self.con.commit()

if open_game.game_should_end():

self.end_game(open_game)

def end_game(self, game):

cur = self.con.cursor()

cur.execute("UPDATE games SET ended = :ended WHERE game_id = :game_id",

dict(game_id=game.game_id, ended=1))

self.con.commit()

game.ended = 1

self.add_stats_game(game=game)

def get_stats(self, stats_id):

cur = self.con.cursor()

q = """ SELECT stats_id, player_id, attack_player_id, defense_player_id, team_id, wins, draws, losses, goals_pro, goals_against, elo_rating, timestamp

FROM STATS

WHERE stats_id = :stats_id

"""

cur.execute(q, dict(stats_id=stats_id))

stats_exists = cur.fetchone()

if stats_exists:

_, player_id, attack_player_id, defense_player_id, team_id, wins, draws, losses, goals_pro, goals_against, elo_rating, timestamp = stats_exists

return Stats(stats_id=stats_id, player_id=player_id, attack_player_id=attack_player_id, defense_player_id=defense_player_id, team_id=team_id,

wins=wins, draws=draws, losses=losses, goals_pro=goals_pro, goals_against=goals_against,

elo_rating=elo_rating, timestamp=timestamp)

else:

return None

def get_all_stats(self, player_id=None, attack_player_id=None, defense_player_id=None, team_id=None, limit=None):

cur = self.con.cursor()

assert 1 == (player_id is not None) + (attack_player_id is not None) + (defense_player_id is not None) + (team_id is not None), "Use only one of these (player_id, attacker_id, defender_id, team_id)"

ids_dict = dict(player_id=player_id, attack_player_id=attack_player_id, defense_player_id=defense_player_id, team_id=team_id)

if player_id:

s_id = "player_id"

elif attack_player_id:

s_id = "attack_player_id"

elif defense_player_id:

s_id = "defense_player_id"

elif team_id:

s_id = "team_id"

else:

pass # will never happen

raise Exception("Assert failed, this should never happen")

q = """ SELECT player_id, attack_player_id, defense_player_id, team_id, wins, draws, losses, goals_pro, goals_against, elo_rating, timestamp

FROM STATS

WHERE {s_id}=:{s_id}

ORDER BY timestamp DESC

""".format(s_id=s_id)

if limit:

q += " LIMIT {limit}".format(limit=limit)

cur.execute(q, ids_dict)

all_stats = list(cur.fetchall())

if len(all_stats) > 0:

stats_list = [Stats(player_id=player_id, attack_player_id=attack_player_id, defense_player_id=defense_player_id, team_id=team_id,

wins=wins, draws=draws, losses=losses,

goals_pro=goals_pro, goals_against=goals_against, elo_rating=elo_rating, timestamp=timestamp)

for player_id, attack_player_id, defense_player_id, team_id, wins, draws, losses, goals_pro, goals_against, elo_rating, timestamp in all_stats]

else:

stats_list = [Stats(**ids_dict)]

return stats_list

def add_first_stats(self, player_id=None, attack_player_id=None, defense_player_id=None, team_id=None, timestamp=tools.get_timestamp_for_now()):

return self.increment_stats(player_id=player_id, attack_player_id=attack_player_id, defense_player_id=defense_player_id, team_id=team_id, timestamp=timestamp)

def increment_stats(self,

player_id=None,

attack_player_id=None,

defense_player_id=None,

team_id=None,

i_wins=0, i_draws=0, i_losses=0,

i_goals_pro=0, i_goals_against=0,

i_elo_rating=0,

timestamp=tools.get_timestamp_for_now()):

"""

Increment the stats of a player, attacker, defender, or team based by certain values

"""

cur = self.con.cursor()

stats = self.get_all_stats(player_id=player_id, attack_player_id=attack_player_id, defense_player_id=defense_player_id, team_id=team_id, limit=1)[0]

stats.update(i_wins=i_wins, i_draws=i_draws, i_losses=i_losses, i_goals_pro=i_goals_pro, i_goals_against=i_goals_against, i_elo_rating=i_elo_rating, timestamp=timestamp)

s = """

INSERT INTO stats(player_id, attack_player_id, defense_player_id, team_id,

wins, draws, losses,

goals_pro, goals_against,

elo_rating, timestamp)

VALUES(:player_id, :attack_player_id, :defense_player_id, :team_id,

:wins, :draws, :losses,

:goals_pro, :goals_against,

:elo_rating, :timestamp)

"""

cur.execute(s, stats.__dict__)

self.con.commit()

stats.stats_id = cur.lastrowid

return stats

def add_stats_game(self, game):

if not game.ended:

raise Exception("Game not ended")

stats_timestamp = game.timestamp

game = self.get_game_by_timestamp(timestamp=stats_timestamp)

# Get all stats

elo_left_team = game.left_team.team_stats.elo_rating

elo_right_team = game.right_team.team_stats.elo_rating

elo_attack_left = game.left_team.attack_player.attack_stats.elo_rating

elo_defense_left = game.left_team.defense_player.defense_stats.elo_rating

elo_attack_right = game.right_team.attack_player.attack_stats.elo_rating

elo_defense_right = game.right_team.defense_player.defense_stats.elo_rating

elo_player_attack_left = game.left_team.attack_player.player_stats.elo_rating

elo_player_defense_left = game.left_team.defense_player.player_stats.elo_rating

elo_player_attack_right = game.right_team.attack_player.player_stats.elo_rating

elo_player_defense_right = game.right_team.defense_player.player_stats.elo_rating

# Score percentages

if (game.left_score+game.right_score) != 0:

score_p_left = game.left_score / float(game.left_score+game.right_score)

score_p_right = 1.0 - score_p_left

else:

score_p_left = 0.5

score_p_right = 0.5

i_elo_left_team = elo.rating_increment(score_perc=score_p_left, diff_ratings=(elo_left_team - elo_right_team))

i_elo_right_team = elo.rating_increment(score_perc=score_p_right, diff_ratings=(elo_right_team - elo_left_team))

i_elo_left_players_pos = elo.rating_increment(score_perc=score_p_left, diff_ratings=((elo_attack_left+elo_defense_left) - (elo_attack_right+elo_defense_right)))

i_elo_right_players_pos = elo.rating_increment(score_perc=score_p_right, diff_ratings=((elo_attack_right+elo_defense_right)-(elo_attack_left+elo_defense_left)))

i_elo_left_players_ind = elo.rating_increment(score_perc=score_p_left, diff_ratings=((elo_player_attack_left+elo_player_defense_left) - (elo_player_attack_right+elo_player_defense_right)))

i_elo_right_players_ind = elo.rating_increment(score_perc=score_p_right, diff_ratings=((elo_player_attack_right+elo_player_defense_right) - (elo_player_attack_left+elo_player_defense_left)))

# Increments for left or right teams

left_dict_goals_increment = dict(i_wins=int(game.left_score > game.right_score),

i_draws=int(game.left_score == game.right_score),

i_losses=int(game.left_score < game.right_score),

i_goals_pro=game.left_score,

i_goals_against=game.right_score,

timestamp=stats_timestamp)

right_dict_goals_increment = dict(i_wins=int(game.right_score > game.left_score),

i_draws=int(game.left_score == game.right_score),

i_losses=int(game.right_score < game.left_score),

i_goals_pro=game.right_score,

i_goals_against=game.left_score,

timestamp=stats_timestamp)

new_left_team_stats = self.increment_stats(team_id=game.left_team.team_id, i_elo_rating=i_elo_left_team, **left_dict_goals_increment)

self.update_team_stats(team_id=game.left_team.team_id, team_stats_id=new_left_team_stats.stats_id)

new_right_team_stats = self.increment_stats(team_id=game.right_team.team_id, i_elo_rating=i_elo_right_team, **right_dict_goals_increment)

self.update_team_stats(team_id=game.right_team.team_id, team_stats_id=new_right_team_stats.stats_id)

new_left_attack_attack_stats = self.increment_stats(attack_player_id=game.left_team.attack_player.player_id, i_elo_rating=i_elo_left_players_pos, **left_dict_goals_increment)

new_left_attack_player_stats = self.increment_stats(player_id=game.left_team.attack_player.player_id, i_elo_rating=i_elo_left_players_ind, **left_dict_goals_increment)

self.update_player_stats(player_id=game.left_team.attack_player.player_id,

player_stats_id=new_left_attack_player_stats.stats_id,

attack_stats_id=new_left_attack_attack_stats.stats_id,

defense_stats_id=game.left_team.attack_player.defense_stats.stats_id) # not changed

new_left_defense_defense_stats = self.increment_stats(defense_player_id=game.left_team.defense_player.player_id, i_elo_rating=i_elo_left_players_pos, **left_dict_goals_increment)

if game.left_team.attack_player.player_id != game.left_team.defense_player.player_id:

new_left_defense_player_stats = self.increment_stats(player_id=game.left_team.defense_player.player_id, i_elo_rating=i_elo_left_players_ind, **left_dict_goals_increment)

else:

new_left_defense_player_stats = new_left_attack_player_stats

self.update_player_stats(player_id=game.left_team.defense_player.player_id,

player_stats_id=new_left_defense_player_stats.stats_id,

attack_stats_id=game.left_team.defense_player.attack_stats.stats_id, #not changed

defense_stats_id=new_left_defense_defense_stats.stats_id)

new_right_attack_attack_stats = self.increment_stats(attack_player_id=game.right_team.attack_player.player_id, i_elo_rating=i_elo_right_players_pos, **right_dict_goals_increment)

new_right_attack_player_stats = self.increment_stats(player_id=game.right_team.attack_player.player_id, i_elo_rating=i_elo_right_players_ind, **right_dict_goals_increment)

self.update_player_stats(player_id=game.right_team.attack_player.player_id,

player_stats_id=new_right_attack_player_stats.stats_id,

attack_stats_id=new_right_attack_attack_stats.stats_id,

defense_stats_id=game.right_team.attack_player.defense_stats.stats_id) # not changed

new_right_defense_defense_stats = self.increment_stats(defense_player_id=game.right_team.defense_player.player_id, i_elo_rating=i_elo_right_players_pos, **right_dict_goals_increment)

if game.right_team.attack_player.player_id != game.right_team.defense_player.player_id:

new_right_defense_player_stats = self.increment_stats(player_id=game.right_team.defense_player.player_id, i_elo_rating=i_elo_right_players_ind, **right_dict_goals_increment)

else:

new_right_defense_player_stats = new_right_attack_player_stats

self.update_player_stats(player_id=game.right_team.defense_player.player_id,

player_stats_id=new_right_defense_player_stats.stats_id,

attack_stats_id=game.right_team.defense_player.attack_stats.stats_id, #not changed

defense_stats_id=new_right_defense_defense_stats.stats_id)

def recalculate_stats(self):

cur = self.con.cursor()

cur.execute("DELETE FROM STATS")

self.con.commit()

players = self.get_all_players()

for player in players:

player_stats = self.add_first_stats(player_id=player.player_id, timestamp=config.FIRST_TIMESTAMP)

attack_stats = self.add_first_stats(attack_player_id=player.player_id, timestamp=config.FIRST_TIMESTAMP)

defense_stats = self.add_first_stats(defense_player_id=player.player_id, timestamp=config.FIRST_TIMESTAMP)

self.update_player_stats(player_id=player.player_id,

player_stats_id=player_stats.stats_id,

attack_stats_id=attack_stats.stats_id,

defense_stats_id=defense_stats.stats_id)

teams = self.get_all_teams()

for team in teams:

team_stats = self.add_first_stats(team_id=team.team_id, timestamp=config.FIRST_TIMESTAMP)

self.update_team_stats(team_id=team.team_id, team_stats_id=team_stats.stats_id)

games = reversed(self.get_all_games())

for game in games: