def receiving_yds_player(request, player_id): if request.method == "POST": return HttpResponse('Cannot POST.') if request.method == "GET": db = nfldb.connect() q = nfldb.Query(db) data = {} seas_year = '2017' player = Player.objects.get(player_id=player_id) name = str(player) team = player.get_team() team_name = player.team.get_team_name() position = player.get_position() weeks = [] receivingydperweek = {} games = q.game(season_year=seas_year, season_type='Regular', team=team).as_games() drives = q.drive(pos_team=team).sort(('start_time', 'asc')).as_drives() for i in range(0, len(games)): if games[i].finished: weeks.append(games[i].week) for w in weeks: receivingydperweek[w] = [] weeks.sort(key=int) for d in drives: receive_yds = 0 for w in weeks: q = nfldb.Query(db).drive(gsis_id=d.gsis_id, drive_id=d.drive_id) q.player(full_name=name) q.game(week=w) results = q.aggregate(receiving_yds__ge=0).as_aggregate() if len(results) == 0: continue tfb = results[0] receive_yds += tfb.receiving_yds for w in weeks: if w == d.game.week: receivingydperweek[w] += [receive_yds] for w in weeks: receivingydperweek[w] = sum(receivingydperweek[w]) data = { 'player': player, 'player_id': player_id, 'name': name, 'team': team, 'team_name': team_name, 'position': position, 'weeks': weeks, 'receiving_per_week': receivingydperweek, } return render(request, "player_receiving.html", {'data': data})
def passblock_player(request, player_id): if request.method == "POST": return HttpResponse('Cannot POST.') if request.method == "GET": db = nfldb.connect() q = nfldb.Query(db) data = {} seas_year = '2017' player = Player.objects.get(player_id=player_id) name = str(player) team = player.get_team() team_name = player.team.get_team_name() position = player.get_position() weeks = [] blkperweek = {} games = q.game(season_year=seas_year, season_type='Regular', team=team).as_games() for i in range(0, len(games)): if games[i].finished: weeks.append(games[i].week) for w in weeks: blkperweek[w] = [] weeks.sort(key=int) for g in games: blocks = 0 q = nfldb.Query(db).play(gsis_id=g.gsis_id) plays = q.player(full_name=name).as_plays() for p in plays: results = p.defense_pass_def blocks += results # print picks # print p for w in weeks: if w == g.week: blkperweek[w] += [blocks] for w in weeks: blkperweek[w] = sum(blkperweek[w]) data = { 'player': player, 'player_id': player_id, 'name': name, 'team': team, 'team_name': team_name, 'position': position, 'weeks': weeks, 'blocks_per_week': blkperweek, } return render(request, "player_blocks.html", {'data': data})
def player_matrix(name, year, weeks): """ Make a player matrix (DataFrame). Rows = weeks Columns = stats Step 1: Get stat categories relevant to player over the given time period (Cols) Step 2: Query all games in time period (get game objects), select those where the player played Step 3: Get player stats game by game, filling in categories/stats in empta data dict Step 4: Create #games x #categories dataframe """ db = nfldb.connect() q = nfldb.Query(db) _labels = q.player(full_name=name).as_aggregate()[0] _cols = list(_labels.fields) data = {} _index = [] q.game(season_year=year, season_type='Regular', week=weeks) games = q.sort(('week', 'asc')).as_games() for i, g in enumerate(games): q = nfldb.Query(db).game(gsis_id=g.gsis_id) stats = q.player(full_name=name).as_aggregate()[0] for category in _cols: if category not in data: data[category] = [getattr(stats, category, None)] else: data[category].append(getattr(stats, category, None)) _index.append(str(g.season_year)+str(g.week)) sorted_index = sorted(_index, key = sort_help) frame = pd.DataFrame(data=data, index=sorted_index) """ Make a unique Fantasy Points Scoring Vector for this player. """ cooper_vector_data = {} for k,v in fanduel_point_conversions.iteritems(): if k in _cols: cooper_vector_data[k]=v cooper_vector = pd.Series(cooper_vector_data) cooper_vector = frame.dot(cooper_vector) frame['fantasy_points']=cooper_vector return frame
def do_query(pos,sta,seasonYear): tm = dict() for k in range (0,len(sta)): for m in range( 0, len(pos) ): if (len(seasonYear) == 0): q= nfldb.Query(ndb) q.player(status=sta[k]) tm[sta[k] +pos[m]] = q.player(position=pos[m]) else : for s in range(0,len(seasonYear)): q= nfldb.Query(ndb) q.player(status=sta[k]) q.player(position=pos[m]) tm[sta[k] +pos[m]+str(seasonYear[s])] = q.game(season_year=seasonYear[s]) return tm
def analyze_malone(): db = nfldb.connect() q = nfldb.Query(db) q.game(season_year__ge=2005).game(season_type='Regular') q.player(full_name="Robert Malone") all_plays = q.as_plays() plays = [{f: l.__getattribute__(f) for f in fields} for l in all_plays] punts = [x for x in plays if sum([x.get(n) for n in punt_fields]) > 0] # get the yardline out of the yardline object for p in punts: p['Field Position'] = p.get('yardline') p['yardline'] = p.get('yardline')._offset df = pd.DataFrame(punts) print(df.head()) df['punting_yds'].plot(kind='hist', bins=42) plt.xlabel('Yards In Air') plt.suptitle('Punt Distances In Air From LOS ', ha='right', fontsize='26') plt.title('Robert Malone\'s punts', loc='left', fontsize='16') plt.yticks([0,5,10,15,20]) plt.tight_layout() plt.axhline(y=0, color='black', linewidth=1.3, alpha=.7) plt.text(x=-15, y=-3, s='footballstatsaredumb.wordpress.com', fontsize=14, color='xkcd:darkgreen', ha='left') plt.show()
def plays_for_game(request): """ Return the Play objects as JSON for the given game's gsis_id. Expected request parameters: `gsisId` - The gsis_id of the game """ gsis_id = request.GET.get("gsisId") db = nfldb.connect() q = nfldb.Query(db) q.game(gsis_id=gsis_id) q.sort(('time', 'desc')) plays = q.as_plays() playsJSON = [] for p in plays: # print "Play time: ", p.time play = { "description": p.description, "down": p.down, "offensiveTeam": p.pos_team, "points": p.points, "scoringTeam": p.scoring_team, "time": str(p.time), "yardline": str(p.yardline), "yardsToGo": p.yards_to_go } playsJSON.append(play) return JsonResponse(playsJSON, safe=False)
def rest_games(season=None, phase=None, week=None, gsis_id=None): if gsis_id is None: q = nfldb.Query(db) q.game(season_year=season, season_type=as_phase(phase), week=week) return map(as_rest_game, nfldb_sort(q).as_games()) else: return as_rest_game(nfldb.Game.from_id(db, gsis_id))
def rest_drives(gsis_id, drive_id=None): if drive_id is None: q = nfldb.Query(db) q.game(gsis_id=gsis_id) return map(as_rest_drive, q.sort(('drive_id', 'asc')).as_drives()) else: return as_rest_drive(nfldb.Drive.from_id(db, gsis_id, drive_id))
def showPlayerStat(player_ID, week_input): statJSON = {} stat_string_list = STAT_STRING_LIST db = nfldb.connect() q = nfldb.Query(db) q.game(season_year=2012, season_type='Regular', week=week_input) q.player(player_id=player_ID) # for p in q.sort([('gsis_id', 'asc'), ('time', 'asc')]).as_plays(): # print p for p in q.as_aggregate(): for index in xrange(len(stat_string_list)): key = stat_string_list[index] value = eval('p.' + stat_string_list[index]) statJSON[key] = value #print key, value #Check for empty week stat due to BYE week if len(q.as_aggregate()) == 0: for index in xrange(len(stat_string_list)): key = stat_string_list[index] statJSON[key] = 0 return statJSON
def get_scores(year, end_year, pos): scores = [] results = [] while (year < end_year): print("{}{}{}".format("*" * 10, year, "*" * 10)) db = nfldb.connect() q = nfldb.Query(db) q.game(season_year=year, season_type='Regular').player(position=pos) results = q.as_aggregate() for pp in results: s = score(pp) pp.score = s if (pp.score > 10): scores.append([pp.player.full_name, pp.score, year]) year += 1 results = sorted(results, key=lambda pp: pp.score) # Gives better K means results analyzeAndDisplayCategories( categorizeDown(results, 5, lambda player: player.score)) analyzeAndDisplayCategories( kMeans(results, 5, 25, lambda player: player.score)) analyzeAndDisplayCategories( kMeansVariant(results, 10, 50, lambda player: player.score)) print(scores) return scores
def test_fill_drive(db): q = nfldb.Query(db) q.drive(gsis_id='2013090800') drives = q.as_drives() nfldb.Drive.fill_games(db, drives) for d in drives: assert d._game is not None
def __init__(self, name, **keyword_params): super(WideReceiverTightEndStats, self).__init__() db = nfldb.connect() q = nfldb.Query(db) if 'year' in keyword_params: q.game(season_year=keyword_params['year'], season_type='Regular') if 'week' in keyword_params: q.game(week=keyword_params['week']) else: q.game(season_type='Regular') q.player(full_name=name, position=keyword_params['position']) stats = q.as_aggregate() if len(stats) > 0: stats = stats[0] self.fumbles_tot = stats.fumbles_tot self.fumbles_lost = stats.fumbles_lost self.receiving_tar = stats.receiving_tar self.receiving_rec = stats.receiving_rec self.receiving_yds = stats.receiving_yds self.receiving_tds = stats.receiving_tds self.receiving_yac_yds = stats.receiving_yac_yds
def getGameList(self, year, week): ''' Returns the list of the week's games in json ''' q = nfldb.Query(self.db) q.game(season_year=year, week=week, season_type='Regular') statistics = {'stats': []} #statistics = [] for game in q.as_games(): game_stats = {} game_str = str(game).split() game_stats['week'] = game_str[3] game_stats['date'] = game_str[5] game_stats['away_team'] = game_str[8] game_stats['home_team'] = game_str[11] # Convert time to 24hr clock time time = str(game_str[7]).split(',')[0] if "pm" in time.lower(): # Make into array split by ":" t = (time.lower().split('pm'))[0].split(":") # Add 12 hours for conversion t[0] = str(int(t[0]) + 12) time = ':'.join(t) game_stats['time'] = time statistics['stats'].append(game_stats) return json.dumps(statistics)
def render_player_info(player_id, year="All", phase="All", week="All"): player = nfldb.Player.from_id(db, player_id) q = nfldb.Query(db).game() if (phase == "Preseason") or (phase == "Regular") or (phase == "Postseason"): q.game(season_type=phase) if 2009 <= int(year) <= 2016: q.game(season_year=year) if 1 <= int(week) <= 17: q.game(week=week) q.player(gsis_name=player.gsis_name, team=player.team) stats = q.as_aggregate() stat_list = {} for stat in stats: for field in stat.fields: # Reverse this so it joins properly with category list stat_list[field] = int(getattr(stat, field)) session['prev_year'] = year session['prev_phase'] = phase session['prev_week'] = week session['prev_player_id'] = str(player.player_id) session['prev_player_name'] = str(player.full_name) return render_template('player.html', player=player, stats=stat_list, stat_names=stat_names, session=session)
def __init__(self, name, **keyword_params): super(KickerStats, self).__init__() db = nfldb.connect() q = nfldb.Query(db) if 'year' in keyword_params: q.game(season_year=keyword_params['year'], season_type='Regular') if 'week' in keyword_params: q.game(week=keyword_params['week']) else: q.game(season_type='Regular') q.player(full_name=name, position='K') stats = q.as_aggregate() if len(stats) > 0: stats = stats[0] self.kicking_fga = stats.kicking_fga self.kicking_fgm = stats.kicking_fgm self.kicking_fgmissed = stats.kicking_fgmissed # maybe -- depends how this works. need to see if per kick or total kicks self.kicking_fgm_yds = stats.kicking_fgm_yds self.kicking_fgmissed_yds = stats.kicking_fgmissed_yds self.kicking_xpa = stats.kicking_xpa self.kicking_xpmade = stats.kicking_xpmade self.kicking_xpmissed = stats.kicking_xpmissed
def __init__(self): self.q = nfldb.Query(Football.db) self.training_years = [2009, 2010, 2011, 2012] self.season_type = 'Regular' self.stat = ['passing_yds'] self.games_back = 6 self.team = 'DEN'
def __init__(self, name): self.name = name # connect to database to get info db = nfldb.connect() q = nfldb.Query(db) q.player(full_name=name) # this currently gets the first player returned # so we may need to change in future info = q.as_players() if len(info) > 0: info = info[0] # store basic info self.position = info.position self.uniform_number = info.uniform_number self.birthdate = info.birthdate self.height = info.height self.weight = info.weight self.college = info.college self.status = info.status self.team = info.team self.years_pro = info.years_pro else: self.position = types.Enums.player_pos.QB self.uniform_number = 1 self.birthdate = "00/00/0000" self.height = 0 self.weight = 0 self.college = "RPI" self.status = "Nonexistent" self.team = "Free" self.years_pro = 0
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 makeWinMatrix(players): db = nfldb.connect() # Get number of players in list size = len(players) playerInd = {} ind = 0 print '\n index\tname' for x in players: x = x.split(' (') print str(ind) + '\t' + x[0] qd = nfldb.Query(db) qd.game(season_year=2015, season_type='Regular') pp = qd.player(full_name=x[0]).as_aggregate() for x in pp: playerInd[ind] = x ind += 1 xcord = 0 allWins = [] allLoses = [] while xcord < size-1: winsList = [] losesList = [] check = playerInd[xcord] loses = 0 ycord = 0 while ycord<size-1: losesList.append(0) if ycord != xcord: against = playerInd[ycord] wins, loses = calcWins(check, against, loses) winsList.append(wins) else: winsList.append(0) ycord += 1 losesList[xcord] = loses rowWins = numpy.array([winsList]) rowLoses = numpy.array([losesList]) allWins.append(rowWins) allLoses.append(rowLoses) xcord += 1 matrixWins = numpy.vstack(allWins) matrixLoses = numpy.vstack(allLoses) print '---------- Wins ----------' print(matrixWins) print '---------- Loses ----------' print(matrixLoses) return matrixWins, matrixLoses
def test_play_sort_points_other_limit(db, qgame): g = qgame.as_games()[0] qscoring = nfldb.Query(db).game(gsis_id=g.gsis_id) scoring_plays = qscoring.play(points__ge=1).as_plays() qgame.sort(['points']).limit(len(scoring_plays)) plays = qgame.as_plays() assert all([p.points > 0 for p in plays])
def test_fill_play(db): q = nfldb.Query(db) q.play(gsis_id='2013090800') plays = q.as_plays() nfldb.Play.fill_drives(db, plays) for p in plays: assert p._drive is not None assert p._drive._game is not None
def current_reception_leaders(db=db): q = nfldb.Query(db) '''return reception leaders for 2013 season ''' q.game(season_year=2013, season_type="Regular") q.player(position='WR') for pp in q.as_players(): print pp.full_name, pp.weight pass
def rest_players(season=None, phase=None, week=None, gsis_id=None): phase = as_phase(phase) q = nfldb.Query(db) if None not in (season, phase, week): q.game(season_year=season, season_type=phase, week=week) if gsis_id is not None: q.game(gsis_id=gsis_id) return map(as_rest_player, q.sort(('full_name', 'asc')).as_players())
def v_games(season, phase, week): phase = as_phase(phase) q = nfldb.Query(db).sort([('finished', 'asc'), ('gsis_id', 'asc')]) games = q.game(season_year=season, season_type=phase, week=week).as_games() return template('games', season=season, phase=phase, week=week, games=games)
def _generate_query(self, weeks): 'Generate a base query to the NFLDB' query = nfldb.Query(self.db) query.game(season_year=self.nfl_year, season_type='Regular', week=weeks) return query
def test_fill_play_player(db): q = nfldb.Query(db) q.play_player(gsis_id='2013090800') pps = q.as_play_players() nfldb.PlayPlayer.fill_plays(db, pps) for pp in pps: assert pp._play is not None assert pp._play._drive is not None assert pp._play._drive._game is not None
def player_stats(db, player_args, game_args={}): # find potential list of players players = nfldb.Query(db).player(**player_args).as_players() # get list of player ids ids = [getattr(pp, 'player_id') for pp in players] player_data = [] for player in players: pid = getattr(player, 'player_id') stats = nfldb.Query(db).game(**game_args).player( player_id=pid).as_aggregate() if len(stats) == 0: stats = None elif len(stats) == 1: stats = stats[0] else: print('something wrong with stats') player_data += [{'info': player, 'stats': stats}] return (player_data)
def tag_players(db, players): """ Given a list of `nflfan.RosterPlayer` objects, set the `nflfan.RosterPlayer.player` attribute to its corresponding `nfldb.Player` object. (Except for roster players corresponding to an entire team, e.g., a defense.) """ ids = [p.player_id for p in players if p.is_player] q = nfldb.Query(db).player(player_id=ids) dbps = dict([(p.player_id, p) for p in q.as_players()]) return [p._replace(player=dbps.get(p.player_id, None)) for p in players]
def top_receiving_tds(w,y): top = list() dic = dict() q = nfldb.Query(ndb) q.game(season_year=y, season_type='Regular') for p in q.sort('receiving_tds').limit(5).as_aggregate(): dic[p.player_id] = {"name":p.player.full_name, "mark0":"T", "period":"season", "team":p.player.team, "receiving_tds":p.receiving_yds} if w != 0 : q = nfldb.Query(ndb) q.game(season_year=y, season_type='Regular', week=w) for p in q.sort('receiving_tds').limit(5).as_aggregate(): dic[p.player_id+ str(w)] = {"name":p.player.full_name, "team":p.player.team, "mark1":"T", "period":"seleted_week", "receiving_tds":p.receiving_tds} if (w-1) != 0 : q = nfldb.Query(ndb) q.game(season_year=y, season_type='Regular', week=(w-1)) for p in q.sort('receiving_tds').limit(5).as_aggregate(): dic[p.player_id+ str(w)] = {"name":p.player.full_name, "team":p.player.team, "mark2":"T", "period":"previous_week", "receiving_tds":p.receiving_tds} for k,v in dic.items(): top.append(v) return top
def module1(): db = nfldb.connect() q = nfldb.Query(db) q.game(season_year=2013, season_type='Regular') for pp in q.sort('passing_yds').limit(10).as_aggregate(): print pp.player, pp.passing_yds q.player(full_name="Tom Brady").play(passing_tds=1) for play in q.as_plays(): print play