def test1():
"""Franchised, Series, 1 Season, 1 Ep"""
p = Producer(name='BBC Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = SeriesEpisode(name="Wolf Hall Ep 1")
ep1.save()
se = Season(name="1", ordinal="1")
se.save()
s = Series(name='Wolf Hall')
s.orgs = [p, d]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = ep1
sa.season = se
sa.save()
f = Franchise(name='Masterpiece')
f.serieses.append(s)
f.save()
def test4():
"""Franchised series with 1 oto"""
p = Producer(name='Ken Burns')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = SeriesEpisode(name="The Scripture of Nature (1851-1890)")
ep1.save()
se = Season(name='Season 2009', ordinal=2009)
se.save()
s = Series(name='The National Parks')
s.orgs = [p, d]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = ep1
sa.season = se
sa.save()
f = Franchise(name='Ken Burns')
f.serieses = [s]
f.save()
def test3():
"""Franchised, Series, Seasoned, with 1 OTO"""
p = Producer(name='BBC Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = SeriesEpisode(name="Scandal in Belgravia")
ep1.save()
se = Season(name="Season 2", ordinal="2")
se.save()
s = Series(name='Sherlock')
s.orgs = [p, d]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = ep1
sa.season = se
sa.save()
# get the previous
f = session.query(Franchise).filter(Franchise.name=="Masterpiece").all()[0]
f.serieses.append(s)
f.save()
def _json_to_season(data):
league = load_league(data[SEASON_LEAGUENAME_LABEL])
schedule = data[SEASON_SCHEDULE_LABEL]
for week in range(len(schedule)):
for game in range(len(schedule[week])):
schedule[week][game][2] = tuple(schedule[week][game][2])
schedule[week][game] = tuple(schedule[week][game])
week = data[SEASON_WEEK_LABEL]
season = Season(league, schedule, week)
season.standings = data[SEASON_STANDINGS_LABEL]
results = {}
for key,jsonresult in data[SEASON_RESULTS_LABEL].items():
results[_to_tuple(key)] = _json_to_game_result(jsonresult)
season.results = results
postseason = None
if(data[SEASON_POSTSEASON_LABEL] != None):
postseason = _json_to_postseason(data[SEASON_POSTSEASON_LABEL])
season.postseason = postseason
return season
def test1112():
"""Series with 1 ep (in a season) and 1 OTO (seasonless)"""
p = Producer(name='Universal')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
se = Season(name='3', ordinal=3)
se.save()
e1 = SeriesEpisode(name="Go West Young Monkey")
e1.seasons = [se,]
e1.save()
e2 = OneTimeOnlyEpisode(name="Curious George XMAS")
e2.save()
s = Series(name="Curious George")
s.onetimeonlys = [e2,]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = e1
sa.save()
def test6():
"""Series with OTO"""
p = Producer(name='WGBH Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
se = Season(name='38', ordinal=38)
se.save()
e1 = OneTimeOnlyEpisode(name="Surviving Ebola")
e1.seasons = [se,]
e1.save()
# get the previous
s = session.query(Series).filter(Series.name=="NOVA").all()[0]
s.seasons = [se,]
s.episodes = [e1,]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = e1
sa.save()
def test_tag():
p = Producer(name='BBC Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = SeriesEpisode(name="Wolf Hall Ep 1")
ep1.save()
se = Season(name="1", ordinal="1")
se.save()
s = Series(name='Wolf Hall')
s.orgs = [p, d]
s.save()
s2 = Series(name='Wolf Hall Subseries')
s2.orgs = [p, d]
s2.save()
#sept = SeriesEpisodeTag(series=s, episode=s2, tag='subseries')
#sept.save()
sept = SeriesRelationTag(parent=s, child=s2, tag='subseries')
sept.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = ep1
sa.season = se
sa.save()
def test_get_season(self):
# create two seasons
classification = Classification(label='test mens')
classification.save()
competition = Competition(
name='div 1',
mode='l',
classification=classification
)
competition.save()
season_1 = Season(label='s1',
start_date=datetime.date.today(),
end_date=datetime.date.today() + datetime.timedelta(365),
competition=competition,
published=True
)
season_2 = Season(label='s2',
start_date=datetime.date.today() + datetime.timedelta(365),
end_date=datetime.date.today() + datetime.timedelta(730),
competition=competition
)
season_1.save()
season_2.save()
self.assertIn(season_1,
Season.get_current_season_by_slugs('test-mens', 'div-1'))
self.assertNotIn(season_2,
Season.get_current_season_by_slugs('test-mens', 'div-1'))
def create_test_data(self):
user = User.get_or_create(123)
user.admin = True
User.get_or_create(12345)
db.session.commit()
team1 = Team.create(user, 'EnvyUs', 'EnvyUs', 'fr', 'nv',
['76561198053858673'])
team2 = Team.create(user, 'Fnatic', 'Fnatic', 'se', 'fntc',
['76561198053858673'])
server = GameServer.create(user, 'myserver1', '127.0.0.1', '27015',
'password', False)
server.in_use = True
GameServer.create(user, 'myserver2', '127.0.0.1', '27016', 'password',
True)
db.session.commit()
season = Season.create(
user, 'Season One Test', datetime.datetime.utcnow(),
datetime.datetime.utcnow() + datetime.timedelta(days=1))
db.session.commit()
Match.create(user, team1.id, team2.id, '', '', 1, False,
'Map {MAPNUMBER}', ['de_dust2', 'de_cache', 'de_mirage'],
season.id, 'always_knife', 'CT', server.id)
db.session.commit()
vetoBan = Veto.create(1, 'EnvyUs', 'de_dust2', 'ban')
vetoPick = Veto.create(1, 'EnvyUs', 'de_overpass', 'pick')
db.session.commit()
def season_create():
if not g.user:
return redirect('/login')
form = SeasonForm(request.form)
if request.method == 'POST':
num_seasons = g.user.seasons.count()
max_seasons = config_setting('USER_MAX_SEASONS')
if max_seasons >= 0 and num_seasons >= max_seasons and not (util.is_admin(g.user) or util.is_super_admin(g.user)):
flash('You already have the maximum number of seasons ({}) created'.format(
num_seasons))
elif form.validate():
season = Season.create(
g.user, form.data['season_title'],
form.data['start_date'], form.data['end_date'])
db.session.commit()
app.logger.info('User {} created season {}'
.format(g.user.id, season.id))
return redirect('/myseasons')
else:
get5.flash_errors(form)
return render_template(
'season_create.html', form=form, user=g.user)
def create_season(classification, competition, season_label, start, end):
competition = Competition(
name=competition,
mode='l',
classification=classification
)
competition.save()
season = Season(label=season_label,
start_date=start,
end_date=end,
competition=competition
)
season.save()
return season
def test_get_seasons2(self):
with app.app_context():
result = Season.lookup('28')
self.assertEqual(result['nfc_champion'], "CAR")
self.assertEqual(result['year'], 2015)
self.assertEqual(result['afc_champion'], 'DEN')
self.assertEqual(result['start_date'], '2015-09-10')
self.assertEqual(result['end_date'], '2016-01-03')
def create_season_and_stat_objects():
for player in data:
player_search = Player.query.filter_by(name=player['Player']).first()
team_search = Team.query.filter_by(abbreviation=player['Team']).first()
stat_line = Statistic(end_yr_team=player['Team'], games_played=int(player['GP']), time_on_ice=round(float(player['TOI']),2), goals=int(player['G']), assists=int(player['A']), points=int(player['P']), primary_points=int(player['P1']), pts_per_60=round(float(player['P/60']),2), p_pts_per_60=round(float(player['P1/60']),2), cf=int(player['CF']), ca=int(player['CA']), corsi_plus_minus=int(player['C+/-']), cf_percentage=round(float(player['CF%']),2), rel_cf=round(float(player['Rel CF%']),2), gf=int(player['GF']), ga=int(player['GA']), plus_minus=int(player['G+/-']), pdo=round(float(player['PDO']),2), zsr=round(float(player['ZSR']),2), weighted_cf=create_weighted_cf(player), weighted_ca=create_weighted_ca(player), weighted_corsi_percentage=create_weighted_corsi_percent(player))
season = Season(year=player['Season'], player=player_search, team=team_search, statistic=stat_line)
db.session.add(season)
db.session.commit()
def test_get_seasons1(self):
with app.app_context():
result = Season.lookup('29')
self.assertEqual(result['nfc_champion'], "ATL")
self.assertEqual(result['year'], 2016)
self.assertEqual(result['afc_champion'], 'NE')
self.assertEqual(result['start_date'], '2016-09-08')
self.assertEqual(result['end_date'], '2017-01-01')
def _initialize():
try:
system("clear")
season = datatool.load_season(sys.argv[1])
return SeasonShell(season)
except (IOError):
league = datatool.load_league(sys.argv[1])
season_schedule = schedule.make_schedule(
[team.get_team_name() for team in league.get_all_teams()])
season = Season(league, season_schedule, 0)
return SeasonShell(season)
def test7():
"""Series with Subseries and 1 Ep"""
p = Producer(name='WGBH Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
se = Season(name='17', ordinal=17)
se.save()
e1 = SeriesEpisode(name="Antiques Roadshow Seattle, Ep1")
e1.seasons = [se,]
e1.save()
sss = Season(name='1', ordinal=1)
sss.save()
ss1 = SubSeries(name="Antiques Roadshow in Seattle")
ss1.save()
s = Series(name="Antiques Roadshow")
s.subseries = [ss1]
s.seasons = [se,]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = e1
sa.save()
sa2 = SeasonAssociation(season=sss)
sa2.series = ss1
sa2.episode = e1
sa2.save()
def test8():
"""Series with EP"""
p = Producer(name='WETA')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = SeriesEpisode(name="Monday, July 15th, 2014")
ep1.save()
s = Series(name='PBS NewsHour')
s.orgs = [p, d]
s.save()
se = Season(name='29', ordinal=29)
se.save()
sa2 = SeasonAssociation(season=se)
sa2.series = s
sa2.episode = ep1
sa2.save()
def convert_season(data: SeasonData) -> Season:
contestants = dict()
teams = []
next_contestant_number = 0
for team_data in data.teams:
team = []
for contestant in sorted(team_data):
contestant_number = contestants.setdefault(contestant,
next_contestant_number)
if contestant_number == next_contestant_number:
next_contestant_number += 1
team.append(contestant_number)
teams.append(team)
weeks = []
week_number = 0
for week_data in data.weeks:
booths = []
for booth_data in week_data.booths:
first = contestants[booth_data.pairing[0]]
second = contestants[booth_data.pairing[1]]
booth = TruthBooth(pairing=(first, second),
outcome=booth_data.outcome)
booths.append(booth)
pairings = set()
# each contestant may only be in one pairing
contestants_copy = dict(contestants)
for pairing_data in week_data.pairings:
first = contestants_copy.pop(pairing_data[0])
second = contestants_copy.pop(pairing_data[1])
pairings.add((first, second))
week = Week(id=week_number,
pairings=pairings,
beams=week_data.beams,
booths=booths)
weeks.append(week)
week_number += 1
sorted_contestants = sorted(contestants.items(), key=lambda x: x[1])
season = Season(contestants=[k for k, v in sorted_contestants],
teams=teams,
weeks=weeks)
return season
def connect_match_data_season_1617():
df = pd.read_csv("./data/season_files/season1617.csv").drop(["Unnamed: 0"],
axis=1)
n_rels = 0
n_nodes = 0
for _, row in df.iterrows():
# NODES
# Hometeam
ht = Team.nodes.get(name=row["Home/Neutral"])
# Visitor
vt = Team.nodes.get(name=row["Visitor/Neutral"])
# HomeScore
hs = Score(score=row["PTS.1"]).save()
# VisitorScore
vs = Score(score=row["PTS"]).save()
# Arena
a = ht.arena.get()
# Season
s = Season.get_or_create({"name": "2016/2017"})[0]
# Date
d = Date.get_or_create({
"datetime":
datetime.strptime(row["Date"] + " " + row["Start (ET)"],
"%Y-%m-%d %I:%M %p")
})[0]
# Game
g = Game(game_name=row["game_name"],
game_type=row["game_type"],
ot=row["OT"]).save()
n_nodes += 1
# RELATIONSHIPS
# Team -> Score
ht.scored.connect(hs)
vt.scored.connect(vs)
# Score -> Game
hs.in_game.connect(g)
vs.in_game.connect(g)
# Game -> Season
g.season.connect(s)
# Game -> Date
g.date.connect(d)
# Game -> Arena
g.arena.connect(a)
n_rels += 7
print("created (approx:) {} nodes and {} relationships".format(
n_nodes, n_rels))
def test9():
"""WEIRD ONE: Series and Subseries of different seasons sharing the same Ep"""
p = Producer(name='WETA Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
se = Season(name='41', ordinal=41)
se.save()
se2 = Season(name='2012', ordinal=2012)
se2.save()
e1 = SeriesEpisode(name="Democratic National Convention September 5, 2015 Part 1")
e1.save()
ss1 = SubSeries(name="Elections")
#ss1.episodes = [e1,]
ss1.seasons = [se2]
ss1.save()
s = session.query(Series).filter(Series.name=="PBS NewsHour").all()[0]
#s = Series(name="PBS NewsHour")
s.subseries = [ss1]
s.seasons = [se,]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = e1
sa.save()
sa2 = SeasonAssociation(season=se2)
sa2.series = ss1
sa2.episode = e1
sa2.save()
def test5():
"""Series with Ep in one season AND Subseries with Ep in a different season"""
p = Producer(name='WGBH Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
se = Season(name='38', ordinal=38)
se.save()
se1 = Season(name='1', ordinal=1)
se1.save()
e1 = SeriesEpisode(name="Making Stuff Similar Episode")
e1.save()
e2 = SeriesEpisode(name="Making Stuff Similar Episode2")
e2.save()
ss1 = SubSeries(name="Making Stuff")
ss1.save()
s = Series(name="NOVA")
s.subseries = [ss1]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = e1
sa.save()
sa2 = SeasonAssociation(season=se1)
sa2.series = ss1
sa2.episode = e2
sa2.save()
def _make_season(serie_id, episodes):
return Season(serie_id, episodes[0].season,
sorted(episodes, key=lambda x: natural_sort_key(x.episode)))
def _make_season(serie_id, episodes):
return Season(serie_id, episodes[0].season, episodes)
def import_schedule(season=None):
# We want to convert from Eastern Time in the schedule to UTC
import pytz
est = pytz.timezone('US/Eastern')
if not season:
season = Season.current()
# Make a map of all the teams. Map by both name and place because the
# input data uses either one, sort of arbitrarily.
teams = Team.all().fetch(32)
team_map = dict((t.name, t) for t in teams)
team_map.update(dict((t.place, t) for t in teams))
# We'll build up the weeks and games we're importing in these structures.
week_map = {}
games = []
csvlines = open('data/examples/2011-2012-schedule.csv').readlines()[1:]
reader = csv.reader(csvlines)
for row in reader:
# Figure out kickoff
kickoff = '%s %s' % itemgetter(0, 7)(row)
kickoff = datetime.datetime.strptime(kickoff, '%m/%d/%Y %I:%M %p')
kickoff = est.localize(kickoff).astimezone(pytz.utc)
# Look up home and away teams by team name in the team map
team_names = [_.strip() for _ in row[-2:]]
home, away = itemgetter(*team_names)(team_map)
# Figure out what week this game belongs to. The data in the CSV is a
# string like this:
# 'NFL Week 8: Chargers @ Chiefs [TV: ESPN]'
info = row[2]
week_num = int(info.split()[2][:-1])
if week_num not in week_map:
key = db.Key.from_path('Week', week_num, parent=season.key())
week_map[week_num] = Week(key=key, name='Week %s' % week_num)
week = week_map[week_num]
key_name = '%s@%s' % (away.slug, home.slug)
game = dict(parent=week,
key_name=key_name,
home_team=home,
away_team=away,
teams=[home.key(), away.key()],
start=kickoff)
games.append(game)
games.sort(key=itemgetter('parent'))
# Figure out each week's end date based on the latest kickoff of its games
for week, week_games in groupby(games, itemgetter('parent')):
week_games = list(week_games)
start = min(game['start'] for game in week_games)
end = max(game['start'] for game in week_games)
week.start = start
week.end = end + datetime.timedelta(hours=5)
# Store the weeks, so they have "complete" keys, and can therefore be used
# as the parents to the games we're about to create.
week_keys = db.put(week_map.values())
# Create actual game entities from the kwargs we gathered, and store them.
games = [Game(**kwargs) for kwargs in games]
game_keys = db.put(games)
return week_keys + game_keys
def get_gamedates(years):
"""
Load the dates and games played on them for the given years supplied
:param years: the years to load info for
:type years: list[str]
"""
# For each specified year, look at the dates and games played on them
for year in years:
season_entry = Season()
season_entry.year = year
# Get the first day of October as the first possible default date
first_date = '{}-10-01'.format(year[:4])
# Iterate until finding first day of regular season
while True:
print("Looking at {} for first day of season".format(first_date))
gameday = query_nba_api(scoreboardv2.ScoreboardV2,
game_date=first_date)
game_ids = gameday.available.get_data_frame()['GAME_ID']
# If there were games this day, and it is regular season
if len(game_ids) > 0 and game_ids[0][2] == '2':
season_entry.first_date = first_date
break
else:
first_date = (datetime.date.fromisoformat(first_date) +
timedelta(1)).isoformat()
# Begin loading into mongo the game dates
date = first_date
while True:
gamedate_entry = GameDate.objects(date=date)
# Game date already exists in database
if gamedate_entry:
print('{} is already in the database'.format(date))
# Else game date is not already in database
else:
gameday = query_nba_api(scoreboardv2.ScoreboardV2,
game_date=date)
game_ids = (
gameday.available.get_data_frame()['GAME_ID'].to_list())
# If all star game, skip
if len(game_ids) > 0 and game_ids[0][2] == '3':
game_ids = []
# If playoff game, stop and mark previous date as last day
if len(game_ids) > 0 and game_ids[0][2] == '4':
last_date = (datetime.date.fromisoformat(date) -
timedelta(1)).isoformat()
season_entry.last_date = last_date
if not Season.objects(year=year):
season_entry.save()
break
# Create gameday entry for this day
gamedate_entry = GameDate()
gamedate_entry.date = date
gamedate_entry.year = year
if '0021201214' in game_ids: # Remove not played game
game_ids.remove('0021201214')
gamedate_entry.games = game_ids
gamedate_entry.save()
print('Adding {} to database with {} games played on '
'this day'.format(date, len(game_ids)))
date = (datetime.date.fromisoformat(date) +
timedelta(1)).isoformat()
def get_games(years):
"""
Load the info and statistics for the game played in the specified years.
Must have already loaded the gamedates for these years in order to fetch
the games themselves.
:param years: the years to load info for
:type years: list[str]
"""
# For each specified year, look at the dates and games played on them
for year in years:
# Load season
season = Season.objects(year=year)
if not season:
print('Season and GameDates not yet loaded for {}'.format(year))
continue
season = season[0]
first_date = season.first_date
last_date = season.last_date
# For each day in the season
days = (datetime.date.fromisoformat(last_date) -
datetime.date.fromisoformat(first_date)).days + 1
for date in (datetime.date.fromisoformat(first_date) + timedelta(n)
for n in range(days)):
print('\n{} Loading date: {} {}\n'.format(
'#' * 20, date, '#' * 20))
date = date.isoformat()
# Fetch GameDate, if it doesn't exist then the season didn't
# properly load and should re-load it
game_date = GameDate.objects(date=date)
if not game_date:
print('GameDate not loaded for {}, you should re-load this '
'season {} in full to get the full season before '
'proceeding.'.format(date, year))
break
game_date = game_date[0]
# For each game on this day
invalid_game_ids = []
for game_id in game_date.games:
# Fetch Game, if it exists already, skip it
game = Game.objects(game_id=game_id)
if game:
continue
game = Game(game_id=game_id)
game.date = date
game.year = year
# Fetch Box Score Summary
try:
box_score_summary = query_nba_api(
boxscoresummaryv2.BoxScoreSummaryV2, game_id=game_id)
except JSONDecodeError:
invalid_game_ids.append(game_id)
# The purpose of this except block is because in 2019-20, covid led
# to games being cancelled. F**k COVID.
if year == '2019-20':
print('F**k COVID. This game was cancelled.')
continue
else:
raise Exception("Game wasn't found.".format(game_id))
# Store inactive players
game.inactives = [
str(inactive_player)
for inactive_player in box_score_summary.inactive_players.
get_data_frame()['PLAYER_ID'].to_list()
]
# Store officials for this game (create Official if needed)
officials_df = clean_boxscore_df(
box_score_summary.officials.get_data_frame(),
index='OFFICIAL_ID',
str_keys=['OFFICIAL_ID'])
officials = []
game.officials = officials
for official_id, official in officials_df.iterrows():
official_name = '{} {}'.format(official['FIRST_NAME'],
official['LAST_NAME'])
official_entry = add_entry_to_db(document_type=Official,
unique_id=official_id,
name=official_name,
year=year,
game_id=game_id)
officials.append(official_id)
# Store home team id and road team id
game_summary = box_score_summary.game_summary.get_data_frame()
home_team_id = str(game_summary['HOME_TEAM_ID'][0])
road_team_id = str(game_summary['VISITOR_TEAM_ID'][0])
# Fetch various relevant box scores to use
# Traditional box score
box_score_traditional = query_nba_api(
boxscoretraditionalv2.BoxScoreTraditionalV2,
game_id=game_id)
players_traditional = clean_boxscore_df(
box_score_traditional.player_stats.get_data_frame(),
index='PLAYER_ID')
teams_traditional = clean_boxscore_df(
box_score_traditional.team_stats.get_data_frame(),
index='TEAM_ID')
# Advanced box score
box_score_advanced = query_nba_api(
boxscoreadvancedv2.BoxScoreAdvancedV2, game_id=game_id)
players_advanced = clean_boxscore_df(
box_score_advanced.player_stats.get_data_frame(),
index='PLAYER_ID')
teams_advanced = clean_boxscore_df(
box_score_advanced.team_stats.get_data_frame(),
index='TEAM_ID')
# Usage box score
box_score_usage = query_nba_api(
boxscoreusagev2.BoxScoreUsageV2, game_id=game_id)
players_usage = clean_boxscore_df(
box_score_usage.sql_players_usage.get_data_frame(),
index='PLAYER_ID')
# Log the current game
team_names = [
'{} {}'.format(team['TEAM_CITY'], team['TEAM_NAME'])
for _, team in teams_traditional.iterrows()
]
print('\n{} Loading game: {} vs. {} {}'.format(
'#' * 10, team_names[0], team_names[1], '#' * 10))
# Create each PlayerGame and map them to player_id
player_games = {}
game.player_games = player_games
for player_id, player in players_traditional.iterrows():
# Gather player info and add to db for this year if not already stored
player_name = player['PLAYER_NAME']
print("Player: {} (id: {})".format(
player_name, player_id))
add_entry_to_db(document_type=Player,
unique_id=player_id,
name=player_name,
year=year,
game_id=game_id)
# Create PlayerGame entry to add to this game
player_game = PlayerGame(player_id=player_id)
player_games[player_id] = player_game
# Store basic data about PlayerGame
if player['TEAM_ID'] == home_team_id:
player_game.home = True
player_game.team_id = home_team_id
player_game.opposing_team_id = road_team_id
else:
player_game.home = False
player_game.team_id = road_team_id
player_game.opposing_team_id = home_team_id
# Create traditional stats entry for this player
traditional_player_entry = GameTraditionalStats()
player_game.traditional_stats = traditional_player_entry
assign_all_values(traditional_player_entry, player)
# Create advanced stats entry for this player
advanced_player_entry = GameAdvancedStats()
player_game.advanced_stats = advanced_player_entry
assign_all_values(advanced_player_entry,
players_advanced.loc[player_id])
# Create usage stats entry for this player
usage_player_entry = GameUsageStats()
player_game.usage_stats = usage_player_entry
assign_all_values(usage_player_entry,
players_usage.loc[player_id])
# Create each TeamGame and map them to team_id
team_games = {}
game.team_games = team_games
for team_id, team in teams_traditional.iterrows():
# Gather team info and add to db for this year if not already stored
team_name = '{} {}'.format(team['TEAM_CITY'],
team['TEAM_NAME'])
print("Team: {} (id: {})".format(team_name, team_id))
add_entry_to_db(document_type=Team,
unique_id=team_id,
name=team_name,
year=year,
game_id=game_id)
# Create TeamGame entry to add to this game
team_game = TeamGame(team_id=team_id)
team_games[team_id] = team_game
# Store basic data about TeamGame
team_game.date = date
if team_id == home_team_id:
team_game.home = True
team_game.opposing_team_id = road_team_id
else:
team_game.home = False
team_game.opposing_team_id = home_team_id
# Create traditional stats entry for this team
traditional_team_entry = GameTraditionalStats()
team_game.traditional_stats = traditional_team_entry
assign_all_values(traditional_team_entry, team)
# Create advanced stats entry for this team
advanced_team_entry = GameAdvancedStats()
team_game.advanced_stats = advanced_team_entry
assign_all_values(advanced_team_entry,
teams_advanced.loc[team_id])
# Save game
game.save()
print("")
# Remove game_id of games that were cancelled (covid) from game dates for
# future iterations
game_date.games = [
game_id for game_id in game_date.games
if game_id not in invalid_game_ids
]
game_date.save()
def import_schedule(season=None):
# We want to convert from Eastern Time in the schedule to UTC
import pytz
est = pytz.timezone("US/Eastern")
if not season:
season = Season.current()
# Make a map of all the teams. Map by both name and place because the
# input data uses either one, sort of arbitrarily.
teams = Team.all().fetch(32)
team_map = dict((t.name, t) for t in teams)
team_map.update(dict((t.place, t) for t in teams))
# We'll build up the weeks and games we're importing in these structures.
week_map = {}
games = []
csvlines = open("data/examples/2011-2012-schedule.csv").readlines()[1:]
reader = csv.reader(csvlines)
for row in reader:
# Figure out kickoff
kickoff = "%s %s" % itemgetter(0, 7)(row)
kickoff = datetime.datetime.strptime(kickoff, "%m/%d/%Y %I:%M %p")
kickoff = est.localize(kickoff).astimezone(pytz.utc)
# Look up home and away teams by team name in the team map
team_names = [_.strip() for _ in row[-2:]]
home, away = itemgetter(*team_names)(team_map)
# Figure out what week this game belongs to. The data in the CSV is a
# string like this:
# 'NFL Week 8: Chargers @ Chiefs [TV: ESPN]'
info = row[2]
week_num = int(info.split()[2][:-1])
if week_num not in week_map:
key = db.Key.from_path("Week", week_num, parent=season.key())
week_map[week_num] = Week(key=key, name="Week %s" % week_num)
week = week_map[week_num]
key_name = "%s@%s" % (away.slug, home.slug)
game = dict(
parent=week,
key_name=key_name,
home_team=home,
away_team=away,
teams=[home.key(), away.key()],
start=kickoff,
)
games.append(game)
games.sort(key=itemgetter("parent"))
# Figure out each week's end date based on the latest kickoff of its games
for week, week_games in groupby(games, itemgetter("parent")):
week_games = list(week_games)
start = min(game["start"] for game in week_games)
end = max(game["start"] for game in week_games)
week.start = start
week.end = end + datetime.timedelta(hours=5)
# Store the weeks, so they have "complete" keys, and can therefore be used
# as the parents to the games we're about to create.
week_keys = db.put(week_map.values())
# Create actual game entities from the kwargs we gathered, and store them.
games = [Game(**kwargs) for kwargs in games]
game_keys = db.put(games)
return week_keys + game_keys
def seasonIndex():
pageNum = int(request.args.get('page', 1))
order = OrderBy.OrderBySeason(request.args.get('order', None)).value()
filters = FilterBy.SeasonFilter(request.args.get('filter', None)).value()
seasons = Season.list(order, filters, pageNum)
return json.dumps(seasons)
