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
