def index(request, year=0, week=0, season_type='Regular'): db = nfldb.connect() current = nfldb.current(db) if year == 0: season_type, year, week = nfldb.current(db) return redirect('index', year, season_type.name, week) q = nfldb.Query(db).game( season_year=year, season_type=season_type, week=week).sort('start_time') games = q.as_games() return render(request, 'games/index.html', {'games_list': games, 'current': current, 'year': year})
def show_season_table(db, player, stype, week_range=None, pos=None): if pos is None: pos = player.position _, cur_year, _ = nfldb.current(db) pstats = [] for year in range(2009, cur_year+1): qgames = nflcmd.query_games(db, player, year, stype, week_range) games = qgames.as_games() if len(games) == 0: continue game_stats = map(partial(nflcmd.Game.make, db, player), games) agg = qgames.sort([]).as_aggregate() pstats.append(nflcmd.Games(db, year, game_stats, agg[0])) spec = prefix_season + nflcmd.columns['season'][nflcmd.pcolumns[pos]] rows = [nflcmd.header_row(spec)] rows += map(partial(nflcmd.pstat_to_row, spec), pstats) if len(pstats) > 1: summary = nfldb.aggregate(pstat._pstat for pstat in pstats)[0] allrows = nflcmd.Games(db, '-', [], summary) allrows._fgs = [] for pstat in pstats: allrows._fgs += pstat.fgs allrows.games += pstat.games rows.append(nflcmd.pstat_to_row(spec, allrows)) print(nflcmd.table(rows))
def prediction_feature_set(db, pipe, infoColumns, pred_year=None, pred_week=None, player_ids=None): pipe.set_params(pipe1__data__db=db) ### prediction data # get information we need to make predictions season_phase, cur_year, cur_week = nfldb.current(db) if(pred_year is None): pred_year = cur_year if(pred_week is None): pred_week = cur_week + 1 pred_yr_wk = [(j, i) for j in range(2009,pred_year-1) for i in range(1,18)] pred_yr_wk += [(pred_year, i) for i in range(1,pred_week+1)] pipe.set_params(pipe1__data__yr_wk = pred_yr_wk) if(player_ids is None): player_ids = week_player_id_list(db, pred_year, pred_week, position='RB') pred_data = pipe.fit_transform(player_ids) pred_info = infoColumns.fit_transform(X=pred_data) # get extra info like team and opponent # should probably be put in to infoColumns transformer later extra_info = player_current_game_info(db, year=pred_year, week=pred_week, player_ids = list(pred_info['player_id'])) join_on = ['player_id'] add_on = ['team', 'opp_team', 'at_home'] pred_info = pred_info.join(extra_info.set_index(join_on).loc[:,add_on], on=join_on) # predict for the last week pred_yr_wk_t = [pred_yr_wk[-1]] garbage_i, predict_i = split_by_year_week(pred_data, pred_yr_wk_t) return((pred_data, predict_i, pred_info, (pred_year, pred_week)))
def schedule(bot, trigger): season_type, season_year, current_week = nfldb.current(db) if current_week is None: bot.reply('not currently in season') return name = trigger.group(2) team = nfldb.standard_team(name) p = None if team == 'UNK': results = nfldb.player_search2(db, name, limit=1000) if len(results) == 0: bot.reply("No player or team matching that name could be found") return else: p = results[0][0] team = p.team weeks = range(18) q = nfldb.Query(db).game(season_type=season_type, season_year=season_year, week=weeks[current_week:current_week + 5], team=team) message = [] if p is not None: message.append('Upcoming schedule for %s' % p) else: message.append('Upcoming schedule for %s' % team) for g in q.sort(('week', 'asc')).as_games(): message.append(str(g)) say_multiline(bot, '\n'.join(message))
def schedule(bot, trigger): season_type, season_year, current_week = nfldb.current(db) if current_week is None: bot.reply("not currently in season") return name = trigger.group(2) team = nfldb.standard_team(name) p = None if team == "UNK": results = nfldb.player_search2(db, name, limit=1000) if len(results) == 0: bot.reply("No player or team matching that name could be found") return else: p = results[0][0] team = p.team weeks = range(18) q = nfldb.Query(db).game( season_type=season_type, season_year=season_year, week=weeks[current_week : current_week + 5], team=team ) message = [] if p is not None: message.append("Upcoming schedule for %s" % p) else: message.append("Upcoming schedule for %s" % team) for g in q.sort(("week", "asc")).as_games(): message.append(str(g)) say_multiline(bot, "\n".join(message))
def v_home(): phase, season, week = nfldb.current(db) params = { 'season': season, 'phase': phase, 'week': week } url = bottle.default_app().get_url('v_games', **params) bottle.response.status = 302 bottle.response.set_header('Location', url) return ''
def v_home(): phase, season, week = nfldb.current(db) params = {'season': season, 'phase': phase, 'week': week} url = bottle.default_app().get_url('v_games', **params) bottle.response.status = 302 bottle.response.set_header('Location', url) return ''
def week_choices(request): response_data = week_choices_dict() db = nfldb.connect() current_week = nfldb.current(db) response_data['current_year'] = current_week[1] response_data['current_week'] = current_week[2] return HttpResponse(json.dumps(response_data), content_type="application/json")
def gameforecast(bot, trigger): """.gameforecast denver gives the forecast for the denver game this week""" week = None team = nfldb.standard_team(trigger.group(2)) if team == 'UNK': bot.reply('I do not know that team') return season_type, season_year, current_week = nfldb.current(db) if week is None: if current_week is None: bot.reply('Not currently in season') return week = current_week q = nfldb.Query(db).game(season_type='Regular', season_year=season_year, week=week, team=team) games = q.as_games() if len(games) == 0: bot.reply('%s is on BYE' % team) return g = games[0] start_time = g.start_time stadium = stadiums[g.home_team] lat, lon = stadium[2] output = [] output.append('Kickoff forecast for %s at %s %s' % (g.away_team, g.home_team, g.start_time.strftime('%Y-%m-%d %I:%M:%S%p'))) if stadium[3] == False: try: forecast = forecastio.load_forecast(forecastio_api_key, lat, lon, time=start_time, units='us') output.append( u'%s %s\u00B0F windspeed %smph from the %s chance of precip %s%%' % (forecast.currently().d['summary'], forecast.currently().d['temperature'], forecast.currently().d['windSpeed'], windbearing(forecast.currently().d['windBearing']), forecast.currently().d['precipProbability'])) except: output.append('there was an error getting the forecast') else: output.append('Dome') say_multiline(bot, '\n'.join(output))
def correct_years_pro(player_id, db): global players db_season = nfldb.current(db)[1] seasons = [s for s in players[player_id]['seasons']] last_season_played = max(seasons) for season in seasons: # player retired if int(db_season) - int(last_season_played) > 1: players[player_id]['seasons'][season]['years_pro'] -= int(last_season_played) - int(season) else: players[player_id]['seasons'][season]['years_pro'] -= int(db_season) - int(season)
def update_current_week_schedule(db): update_nflgame_schedules() phase_map = nfldb.types.Enums._nflgame_season_phase phase, year, week = nfldb.current(db) log('Updating schedule for (%s, %d, %d)' % (phase, year, week)) with nfldb.Tx(db) as cursor: for gsis_id, info in nflgame.sched.games.items(): if year == info['year'] and week == info['week'] \ and phase == phase_map[info['season_type']]: g = game_from_id(cursor, gsis_id) for table, prim, vals in g._rows: nfldb.db._upsert(cursor, table, vals, prim) log('done.')
def update_current_week_schedule(db): update_nflgame_schedules() phase_map = nfldb.types.Enums._nflgame_season_phase phase, year, week = nfldb.current(db) log('Updating schedule for (%s, %d, %d)' % (phase, year, week)) with nfldb.Tx(db) as cursor: for gsis_id, info in dict(nflgame.sched.games).items(): if year == info['year'] and week == info['week'] \ and phase == phase_map[info['season_type']]: g = game_from_id(cursor, gsis_id) for table, prim, vals in g._rows: nfldb.db._upsert(cursor, table, vals, prim) log('done.')
def v_query(): params = bottle.request.params args = {} if 'game_season_year' in params: args['season'] = params.get('game_season_year') if 'game_season_type' in params: args['phase'] = as_phase(params.get('game_season_type')) if 'game_week' in params: args['week'] = params.get('game_week') phase, season, week = nfldb.current(db) args.setdefault('season', season) args.setdefault('phase', phase) args.setdefault('week', week) return template('query', **args)
def gameforecast(bot, trigger): """.gameforecast denver gives the forecast for the denver game this week""" week = None team = nfldb.standard_team(trigger.group(2)) if team == "UNK": bot.reply("I do not know that team") return season_type, season_year, current_week = nfldb.current(db) if week is None: if current_week is None: bot.reply("Not currently in season") return week = current_week q = nfldb.Query(db).game(season_type="Regular", season_year=season_year, week=week, team=team) games = q.as_games() if len(games) == 0: bot.reply("%s is on BYE" % team) return g = games[0] start_time = g.start_time stadium = stadiums[g.home_team] lat, lon = stadium[2] output = [] output.append( "Kickoff forecast for %s at %s %s" % (g.away_team, g.home_team, g.start_time.strftime("%Y-%m-%d %I:%M:%S%p")) ) if stadium[3] == False: try: forecast = forecastio.load_forecast(forecastio_api_key, lat, lon, time=start_time, units="us") output.append( u"%s %s\u00B0F windspeed %smph from the %s chance of precip %s%%" % ( forecast.currently().d["summary"], forecast.currently().d["temperature"], forecast.currently().d["windSpeed"], windbearing(forecast.currently().d["windBearing"]), forecast.currently().d["precipProbability"], ) ) except: output.append("there was an error getting the forecast") else: output.append("Dome") say_multiline(bot, "\n".join(output))
def get_player_stats_by_season(player_id, db): season_type, current_year, week = nfldb.current(db) player_seasons = [] for year in range(2000, current_year): q = nfldb.Query(db).player(player_id=player_id) res = q.game(season_year=year).as_aggregate() if(len(res) == 1): agg = res[0] pass_avg, rushing_avg, receiving_avg = get_averages(agg) player_seasons.append({ 'player': agg, 'season': year, 'pass_avg': pass_avg, 'rushing_avg': rushing_avg, 'receiving_avg': receiving_avg}) return player_seasons
def schedule_week(bot, trigger): week = None if trigger.group(2) is not None: try: week = int(trigger.group(2)) except: bot.reply("not a valid week") return season_type, season_year, current_week = nfldb.current(db) if season_year is None: bot.say("not currently in season") return if week is None: week = current_week q = nfldb.Query(db).game(season_type="Regular", season_year=season_year, week=week) message = [str(g) for g in q.sort(("start_time", "asc")).as_games()] say_multiline(bot, "\n".join(message))
def schedule_week(bot, trigger): week = None if trigger.group(2) is not None: try: week = int(trigger.group(2)) except: bot.reply('not a valid week') return season_type, season_year, current_week = nfldb.current(db) if season_year is None: bot.say('not currently in season') return if week is None: week = current_week q = nfldb.Query(db).game(season_type='Regular', season_year=season_year, week=week) message = [str(g) for g in q.sort(('start_time', 'asc')).as_games()] say_multiline(bot, '\n'.join(message))
def get_player_stats_by_game(player_id, db): # Get the season typ, year, and week season_type, year, week = nfldb.current(db) q = nfldb.Query(db).player(player_id=player_id) games = q.game( season_year=year, season_type=season_type, week__le=week).sort( ('week', 'asc')).as_games() player_games = [] for game in games: agg = nfldb.Query(db).player( player_id=player_id).game( gsis_id=game.gsis_id).as_aggregate()[0] pass_avg, rushing_avg, receiving_avg = get_averages(agg) player_games.append({'player': agg, 'game': game, 'pass_avg': pass_avg, 'rushing_avg': rushing_avg, 'receiving_avg': receiving_avg}) return player_games
def run(): """Runs the `nflstats` command.""" db = nfldb.connect() _, cur_year, _ = nfldb.current(db) parser = argparse.ArgumentParser( description='Show NFL game stats for a player.') aa = parser.add_argument aa(dest='player_query', metavar='PLAYER', nargs='+') aa('--team', type=str, default=None, help='Specify the team of the player to help the search.') aa('--pos', type=str, default=None, help='Specify the position of the player to help the search.') aa('--soundex', action='store_true', help='When set, player names are compared using Soundex instead ' 'of Levenshtein.') aa('--year', type=str, default=cur_year, help='Show game logs for only this year. (Not applicable if ' '--season is set.)') aa('--pre', action='store_true', help='When set, only games from the preseason will be used.') aa('--post', action='store_true', help='When set, only games from the postseason will be used.') aa('--weeks', type=str, default='', help='Show stats only for the inclusive range of weeks given,\n' 'e.g., "4-8". Other valid examples: "4", "-8",\n' '"4-". Has no effect when --season is used.') aa('--season', action='store_true', help='When set, statistics are shown by season instead of by game.') aa('--show-as', type=str, default=None, help='Force display of player as a particular position. This may need ' 'to be set for inactive players.') args = parser.parse_args() args.player_query = ' '.join(args.player_query) player = nflcmd.search(db, args.player_query, args.team, args.pos, args.soundex) if player is None: eprint("Could not find a player given the criteria.") sys.exit(1) print('Player matched: %s' % player) week_range = nflcmd.arg_range(args.weeks, 1, 17) stype = 'Regular' if args.pre: stype = 'Preseason' if args.post: stype = 'Postseason' pos = None if args.show_as is not None: pos = nfldb.Enums.player_pos[args.show_as] elif player.position == nfldb.Enums.player_pos.UNK: q = nfldb.Query(db) q.play_player(player_id=player.player_id) q.sort(('gsis_id', 'desc')) pos = nfldb.guess_position(q.as_play_players()) if pos == nfldb.Enums.player_pos.UNK: eprint("The player matched is not active and I could not guess\n" "his position. Specify it with the '--show-as' flag.") sys.exit(1) print("Guessed position: %s" % pos) if args.season: show_season_table(db, player, stype, week_range, pos) else: show_game_table(db, player, args.year, stype, week_range, pos)
def rest_current(): phase, season, week = nfldb.current(db) return {'phase': str(phase), 'season': season, 'week': week}
data.append(row) data = pd.DataFrame(data) return data if False: players2dict(player_id2player(week_player_id_list(db, 2015, 6))) db = nfldb.connect() q = nfldb.Query(db) players2dict(player_id2player(week_player_id_list(db, 2015, 6))) # get current season phase, year, week season_phase, cur_year, cur_week = nfldb.current(db) pred_week = cur_week # master list of teams - all teams play in week 1 all_teams = week_team_list(db, cur_year, week=1) # master list of players all_players = players2dict(nfldb.Query(db).player(team=all_teams).as_players()) # list of teams playing for a week week_teams = week_team_list(db, cur_year, week=pred_week) # list of all players on those teams week_players = [plyr for plyr in all_players if plyr['team'] in week_teams]
def run(): """Runs the `nflrank` command.""" db = nfldb.connect() _, cur_year, _ = nfldb.current(db) parser = argparse.ArgumentParser( description='Show NFL player rankings for statistical categories.') aa = parser.add_argument aa(dest='categories', metavar='CATEGORY', nargs='+') aa('--years', type=str, default=str(cur_year), help='Show rankings only for the inclusive range of years given,\n' 'e.g., "2010-2011". Other valid examples: "2010", "-2010",\n' '"2010-".') aa('--weeks', type=str, default='', help='Show rankings only for the inclusive range of weeks given,\n' 'e.g., "4-8". Other valid examples: "4", "-8",\n' '"4-".') aa('--pre', action='store_true', help='When set, only data from the preseason will be used.') aa('--post', action='store_true', help='When set, only data from the postseason will be used.') aa('--pos', type=str, default=[], nargs='+', help='When set, only show players in the given positions.') aa('--teams', type=str, default=[], nargs='+', help='When set, only show players currently on the given teams.') aa('--limit', type=int, default=10, help='Restrict the number of results shown.') args = parser.parse_args() for cat in args.categories: if cat not in nfldb.stat_categories: eprint("%s is not a valid statistical category.", cat) sys.exit(1) stype = 'Regular' if args.pre: stype = 'Preseason' if args.post: stype = 'Postseason' years = nflcmd.arg_range(args.years, 2009, cur_year) weeks = nflcmd.arg_range(args.weeks, 1, 17) def to_games(agg): syrs = years[0] if len(years) == 1 else '%d-%d' % (years[0], years[-1]) qgames = nflcmd.query_games(db, agg.player, years, stype, weeks) return nflcmd.Games(db, syrs, qgames.as_games(), agg) catq = nfldb.QueryOR(db) for cat in args.categories: k = cat + '__ne' catq.play_player(**{k: 0}) q = nfldb.Query(db) q.game(season_year=years, season_type=stype, week=weeks) q.andalso(catq) if len(args.pos) > 0: posq = nfldb.QueryOR(db) for pos in args.pos: posq.player(position=nfldb.Enums.player_pos[pos]) q.andalso(posq) if len(args.teams) > 0: q.player(team=args.teams) q.sort([(cat, 'desc') for cat in args.categories]) q.limit(args.limit) pstats = map(to_games, q.as_aggregate()) spec = ['name', 'team', 'game_count'] + args.categories rows = [nflcmd.header_row(spec)] rows += map(partial(nflcmd.pstat_to_row, spec), pstats) print(nflcmd.table(rows))
print format(field + ':', '8s') + ' ' + format( str(field_val), '8s') + ' * ' + format(str(getattr( pp, field)), '8s') + ' = ' + format( str(getattr(pp, field) * field_val), '8s') def playerGames(player, game, cur_player): if (cur_player.full_name == player): print player + ' - week ' + str( game.week) + ': ' + game.home_team + ' VS ' + game.away_team #get a DB connection db = nfldb.connect() #get current status of the season db_season_phase = nfldb.current(db)[ 0] #can be preseacon, regular, or postseason db_season_year = nfldb.current(db)[1] #current season year db_current_week = nfldb.current(db)[2] #current week of this season phase #positions_sort is used later to figure out the best position player out of a group positions_sort = { 'QB': 'passing_yds', 'RB': 'rushing_yds', 'WR': 'receiving_yds', 'TE': 'receiving_yds', 'K': 'kicking_fgm' } #take the RealDictRows returned from the DB query and convert them to dictionaries #with extra attributes for each player category we can work with positions = ['QB', 'RB', 'WR', 'TE', 'K']