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 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 __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 getOpponent(team_input, week_input):
statJSON = {}
STAT_STRING_OPPONENT = ['passing_yds', 'passing_tds', 'rushing_yds','receiving_yds', 'receiving_tds' ,'kickret_tds', 'fumbles_rec_tds','rushing_tds']
stat_string_list = STAT_STRING_OPPONENT
stat_season_totals = [0 for x in range(len(stat_string_list))]
#stat_string_list = ['puntret_tds']
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2012, season_type='Regular', week=week_input, team=team_input)
#check for bye week all stats = 0
if len(q.as_games())==0:
team_home_away = 'bye'
statJSON['opponent']= 'bye'
for index in xrange(len(stat_string_list)):
statJSON[stat_string_list[index]+'_allowed'] = 0
return statJSON
for p in q.as_games():
if p.away_team == team_input:
opponent = p.home_team
else:
opponent = p.away_team
statJSON['opponent'] = opponent
#print "Team: ", team_input, " has Opponent: ", opponent
q.game(season_year=2012, season_type='Regular', week=week_input, team=opponent)
for p in q.as_games():
for index in xrange(len(stat_string_list)):
stat = showStat(stat_string_list[index], opponent, week_input)
statJSON[stat_string_list[index]+'_allowed'] = stat
stat_season_totals[index] +=stat
#print statJSON
return statJSON
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 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 playerstats(self, **kwargs):
player = kwargs['player']
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=kwargs['season'], season_type='Regular')
if kwargs['targtype'] == "non-redzone":
pos1 = nfldb.FieldPosition.from_str('OWN 1')
pos2 = nfldb.FieldPosition.from_str('OPP 21')
#OPP 20 to OPP 10 yardline
elif kwargs['targtype'] == 'redzone':
pos1 = nfldb.FieldPosition.from_str('OPP 20')
pos2 = nfldb.FieldPosition.from_str('OPP 11')
#OPP 10 to OPP 6
elif kwargs['targtype'] == 'goaline1':
pos1 = nfldb.FieldPosition.from_str('OPP 10')
pos2 = nfldb.FieldPosition.from_str('OPP 6')
# OPP 5 to OPP 3
elif kwargs['targtype'] == 'goaline2':
pos1 = nfldb.FieldPosition.from_str('OPP 5')
pos2 = nfldb.FieldPosition.from_str('OPP 3')
#OPP 2 or OPP 1
elif kwargs['targtype'] == 'goaline3':
pos1 = nfldb.FieldPosition.from_str('OPP 2')
pos2 = nfldb.FieldPosition.from_str('OPP 1')
q.play(yardline__ge=pos1)
q.play(yardline__le=pos2)
q.player(full_name= player)
for pp in q.as_aggregate():
return pp
def showStatDefense(team_input, week_input):
statJSON = {}
#STAT_STRING_LIST_DEFENSE=['defense_sk', 'defense_int', 'defense_frec', 'defense_safe', 'defense_frec_tds', 'defense_int_tds', 'defense_misc_tds', 'kickret_tds']
stat_string_list = STAT_STRING_LIST_DEFENSE
stat_season_totals = [0 for x in range(len(stat_string_list))]
#stat_string_list = ['puntret_tds']
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2012, season_type='Regular', week=week_input, team=team_input)
for p in q.as_games():
if p.away_team == team_input:
statJSON['points_allowed']= p.home_score
else:
statJSON['points_allowed']= p.away_score
#check for bye week all stats = 0
if len(q.as_games())==0:
team_home_away = 'bye'
for index in xrange(len(stat_string_list)):
statJSON[stat_string_list[index]] = 0
return statJSON
for index in xrange(len(stat_string_list)):
stat = showStat(stat_string_list[index], team_input, week_input)
statJSON[stat_string_list[index]] = stat
#stat_season_totals[index] +=stat
statJSON['defense_touchdowns'] = statJSON['defense_int_tds'] + statJSON['defense_frec_tds'] + statJSON['defense_misc_tds']
# for key, index in statJSON.items():
#print ("Totals Week: " +str(week_input) + " " + team_input + " " + key+ " "+ str(index) + '\n')
return statJSON
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 __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 __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 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 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 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 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 __init__(self, name, seasonyear):
self.__name = name
self.__seasonYear = seasonyear
__nfldbConnect = nfldb.connect()
q = nfldb.Query(__nfldbConnect).game(season_year=self.__seasonYear, season_type='Regular')
for pp in q.as_aggregate():
print pp.player
return
def games_played(self,player,year):
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=year, season_type='Regular',)
q.player(full_name=player)
if q.as_games() != None:
return len(q.as_games())
else:
return 0
def __init__(self, name = "Team", short_name = "UNK", year = 2009):
self.name = name
self.short_name = short_name
self.possession = False
self.year = year
self.db = nfl.connect()
self.q = nfl.Query(self.db)
self.q.player(team=short_name)
self.roster = self.q.as_aggregate()
print self.name
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 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
def get_weeklypts(team, week, year):
players = []
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=year, season_type='Regular', team=team, week=week )
for p in q.as_players():
if p.team == team and p.team != "UNK":
pts = get_weeklypoints(year,p.full_name, week)
if pts != 0:
players.append((p.full_name,str(p.position),str(p.team), week, pts))
return players
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
def __init__(self, game_cfg=None):
self.stub = path.abspath(path.dirname(__file__)) + "/../{0}"
if game_cfg is None:
game_cfg = self.stub.format(DEFAULT_FILE_LOCATION)
super(GameEngine, self).__init__(game_cfg)
# DB Connection
self._conn = connect()
# Game elements
self.scoring_method = self._config_handler("scoring_method")
self.fantasy_team = self._config_handler("fantasy_team", conn=self._conn)
def query_players_by_year(self, year):
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=year, season_type='Regular')
# Only retrieving a limited amount to avoid more manual position tagging
rushers = q.sort('rushing_yds').limit(100).as_aggregate()
receivers = q.sort('receiving_yds').limit(100).as_aggregate()
passers = q.sort('passing_yds').limit(35).as_aggregate()
players = self.aggpps_to_players(rushers + receivers + passers)
return players
def testCheck(self):
return
db = nfldb.connect()
calc = Trade.Calculator(PURE)
q = nfldb.Query(db)
q.game(season_year=2009, season_type='Regular')
rushers = q.sort('rushing_yds').limit(100).as_aggregate()
receivers = q.sort('receiving_yds').limit(100).as_aggregate()
passers = q.sort('passing_yds').limit(35).as_aggregate()
players = Trade.aggpps_to_players(rushers + receivers + passers)
for rec,yds in calc.sort_position_more(players, 'TE'):
print "{} {}".format(rec,yds)
def games_for_week(request):
"""
Return the Game objects as JSON for the given NFL week.
Expected request parameters:
`year` - The year of the games to return
`weekType` - Either `pre`(season), `reg`(ular season), or
`post`(season)
`week` - The number of the week within the context of the given year
and week type
"""
year = request.GET.get("year")
week_type = request.GET.get("weekType")
week_num = request.GET.get("week")
db = nfldb.connect()
q = nfldb.Query(db)
if week_type == 'post' and week_num in ['4', '5']:
# Super bowl is either week 4 or 5 based on year
q.game(season_year=year,
season_type=WEEK_TYPE_MAP[week_type],
week=[4, 5])
else:
q.game(season_year=year,
season_type=WEEK_TYPE_MAP[week_type],
week=week_num)
q.sort(('start_time', 'asc'))
games = q.as_games()
gamesJSON = []
for g in games:
game = {
"gsisId": g.gsis_id,
"awayTeam": g.away_team,
"awayScore": g.away_score,
"homeTeam": g.home_team,
"homeScore": g.home_score,
"dayOfWeek": str(g.day_of_week),
"startYear": g.start_time.year,
"startMonth": g.start_time.month,
"startMonthName": g.start_time.strftime("%B"),
"startDate": g.start_time.day,
"startHour":
g.start_time.strftime("%I").lstrip("0").replace(" 0", " "),
"startMinute": g.start_time.strftime("%M"),
"startAmPm": g.start_time.strftime("%p"),
"timeZone": g.start_time.strftime("%Z"),
"finished": g.finished,
"isPlaying": g.is_playing
}
gamesJSON.append(game)
return JsonResponse(gamesJSON, safe=False)
def nfldb(year = 2013):
import nfldb
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=year, season_type='Regular')
for pp in q.sort('passing_yds').limit(15).as_aggregate():
print pp.player, pp.passing_yds, pp.rushing_tds
print "\n"
for pp in q.sort('rushing_yds').limit(15).as_aggregate():
print pp.player, pp.rushing_yds, pp.rushing_tds
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 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 get_ptsagainst(team, year):
db = nfldb.connect()
q = nfldb.Query(db)
results = []
q.game(season_year=year, season_type='Regular', team=team )
for game in q.as_games():
if game.finished:
if game.home_team == team:
opp = game.away_team
elif game.away_team == team:
opp = game.home_team
players = get_weeklypts(opp,game.week,year)
for x in players:
results.append(x)
return results
def player_detail(request, player_id):
db = nfldb.connect()
player = nfldb.Player.from_id(db, player_id)
if (player is None):
raise Http404
player_games = get_player_stats_by_game(player_id, db)
player_seasons = get_player_stats_by_season(player_id, db)
template = select_player_template(player)
return render(request, template,
{
'player': player,
'player_games': player_games,
'player_seasons': player_seasons
})
def testAggPPToPlayer(self):
playerDB = Trade.PlayerDB()
db = nfldb.connect()
q = nfldb.Query(db)
q.game(gsis_id='2009091000')
player1 = q.sort('passing_yds').limit(1).as_aggregate()[0]
self.assertEqual(playerDB.aggpp_to_player(player1), self.test_player1)
player2 = q.sort('rushing_yds').limit(1).as_aggregate()[0]
self.assertEqual(playerDB.aggpp_to_player(player2), self.test_player2)
player_list = [player1, player2]
self.assertEqual(playerDB.aggpps_to_players(player_list),
[self.test_player1, self.test_player2])
def main():
global db, conf
p = argparse.ArgumentParser(description='Run the NFLfan web interface.')
p.add_argument('--config',
metavar='DIR',
default='',
help='Configuration directory.')
p.add_argument('--debug',
action='store_true',
help='Enable Bottle\'s debug mode.')
p.add_argument('--reload',
action='store_true',
help='Enable Bottle\'s reloading functionality.')
p.add_argument('--port', type=int, default=8080)
p.add_argument('--host', default='localhost')
p.add_argument('--server',
default='wsgiref',
help='The web server to use. You only need to change this '
'if you\'re running a production server.')
p.add_argument('--available-servers',
action='store_true',
help='Shows list of available web server names and quits.')
args = p.parse_args()
if args.available_servers:
for name in sorted(bottle.server_names):
try:
__import__(name)
print(name)
except:
pass
sys.exit(0)
bottle.TEMPLATE_PATH.insert(0, path.join(web_path, 'tpl'))
db = nfldb.connect()
conf = nflfan.load_config(providers=nflfan.builtin_providers,
file_path=args.config)
builtins['db'] = db
builtins['conf'] = conf
bottle.install(exec_time)
bottle.run(server=args.server,
host=args.host,
port=args.port,
debug=args.debug,
reloader=args.reload)
def showStat(stat_input, team_input, week_input):
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2012, season_type='Regular', week=week_input)
query_string = stat_input + '__ne'
query_stat = {}
query_stat[query_string] = 0
query_stat['team'] = team_input
q.play(**query_stat)
totals = 0
for pp in q.as_aggregate():
totals += eval('pp.' + stat_input)
#print pp.player, eval('pp.'+stat_input)
#print ("Totals Week: " +str(week_input) + " " + team_input + " " + stat_input+ " "+ str(totals) + '\n')
return totals
def main(season_year):
db = nfldb.connect()
q = nfldb.Query(db).game(season_year=season_year, season_type='Postseason')
team_file = 'playoff_' + str(season_year+1) + '_team_master.json'
with open(team_file) as f:
teams = json.load(f)
point_file = 'playoff_' + str(season_year+1) + '_point_key.json'
with open(point_file) as f:
point_key = json.load(f)
add_points_to_teams(db, teams, point_key, write_time=False)
write_json(teams, write_dir='teams_'+str(season_year+1), write_time=False)
def game_detail(request, gsid):
db = nfldb.connect()
q = nfldb.Query(db).game(gsis_id=gsid)
games = q.as_games()
if (len(games) != 1):
raise Http404
game = games[0]
year = game.season_year
week = game.week
season_type = game.season_type
games = nfldb.Query(db).game(
season_year=year,
season_type=season_type,
week=week).sort('start_time').as_games()
q.player(team=game.away_team)
away_pass = q.aggregate(passing_att__gt=0).sort(
'passing_yds').as_aggregate()
home_pass = nfldb.Query(db).game(
gsis_id=gsid).player(
team=game.home_team).aggregate(
passing_att__gt=0).sort('passing_yds').as_aggregate()
home_rec = nfldb.Query(db).game(
gsis_id=gsid).player(
team=game.home_team).aggregate(
receiving_rec__gt=0).sort('receiving_yds').as_aggregate()
away_rec = nfldb.Query(db).game(
gsis_id=gsid).player(
team=game.away_team).aggregate(
receiving_rec__gt=0).sort('receiving_yds').as_aggregate()
away_run = nfldb.Query(db).game(
gsis_id=gsid).player(
team=game.away_team).aggregate(
rushing_att__gt=0).sort('rushing_yds').as_aggregate()
home_run = nfldb.Query(db).game(
gsis_id=gsid).player(
team=game.home_team).aggregate(
rushing_att__gt=0).sort('rushing_yds').as_aggregate()
return render(request, 'games/detail.html',
{'game': game,
'away_run': away_run,
'home_run': home_run,
'away_pass': away_pass,
'home_pass': home_pass,
'home_rec': home_rec,
'away_rec': away_rec,
'games': games,
})
def showStat(stat_input, team_input, week_input):
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2012, season_type='Regular', week=week_input)
query_string = stat_input + '__ne'
query_stat = {}
query_stat[query_string] = 0;
query_stat['team'] = team_input
q.play( **query_stat)
totals = 0
for pp in q.as_aggregate():
totals+= eval('pp.' + stat_input)
#print pp.player, eval('pp.'+stat_input)
#print ("Totals Week: " +str(week_input) + " " + team_input + " " + stat_input+ " "+ str(totals) + '\n')
return totals
def get_fantasypoints(year, player):
db = nfldb.connect()
q = nfldb.Query(db)
x = nfldb.Query(db)
q.game(season_year=year, season_type='Regular')
q.player(full_name=player)
results = []
for p in q.as_players():
team = p.team
for game in q.as_games():
if game.home_team == team:
opp = game.away_team
if game.away_team == team:
opp = game.home_team
week = game.week
results.append((player, week, opp, get_weeklypoints(year,player,week)))
return results
def get_weeklypoints(year, player, week):
db = nfldb.connect()
x = nfldb.Query(db)
x.game(season_year=year, week=week, season_type='Regular')
x.player(full_name=player)
pts = 0
for game in x.as_aggregate():
if game.fumbles_lost:
pts = pts - 1
if game.puntret_tds:
pts = pts + 6
if game.fumbles_rec_tds:
pts = pts + 6
if game.rushing_att:
if game.rushing_yds:
pts = pts + (game.rushing_yds * .1)
if game.rushing_yds > 100:
pts = pts + 3
if game.rushing_tds:
pts = pts + (game.rushing_tds * 6)
if game.rushing_twoptm:
pts = pts + (game.rushing_twoptm * 2)
if game.passing_att:
if game.passing_yds:
pts = pts + (game.passing_yds * .04)
if game.passing_yds > 300:
pts = pts + 3
if game.passing_tds:
pts = pts + (game.passing_tds * 4)
if game.passing_int:
pts = pts - 1
if game.passing_twoptm:
pts = pts + (game.passing_twoptm * 2)
if game.receiving_tar:
if game.receiving_yds:
pts = pts + (game.receiving_yds * .1)
if game.receiving_yds > 100:
pts = pts + 3
if game.receiving_rec:
pts = pts + game.receiving_rec
if game.receiving_tds:
pts = pts + (6 * game.receiving_tds)
if game.receiving_twoptm:
pts = pts + (2 * game.receiving_twoptm)
return pts
def __init__(self):
self.db = nfl.connect()
self.q = nfl.Query(self.db)
self.conn = psycopg2.connect(database="nfldb", user="******", password="******", host="127.0.0.1", port="5432")
c = self.conn.cursor()
c.execute("""
SELECT team_id
FROM team
""")
teams = c.fetchall()
for team in teams:
#self.field_goal_chance(team[0], db, q)
self.conn.close()
def field_goal_chance(self, team_name):
self.q.player(team=team_name)
roster = self.q.as_aggregate()
attempts = 0
made = 0
for stats in roster:
attempts += stats.kicking_fga
made += stats.kicking_fgm
chance = ( float(made) / float(attempts) ) * 1000
c = self.conn.cursor()
c.execute("""
INSERT INTO team_stats (team_name, stat_key, stat_value)
VALUES ( %s, %s, %d ) """ % ( team_name, 'field_goal_chance', chance )
)
def create_table(self):
print "Open DB"
c = conn.cursor()
c.execute("""
CREATE TABLE team_stats
( stat_id INT PRIMARY KEY NOT NULL,
team_name VARCHAR(5) NOT NULL,
stat_key VARCHAR(255) NOT NULL,
stat_value INT NOT NULL
);
""")
print "Table Created"
conn.commit()
conn.close()
def get_best_name(self, n):
db = nfldb.connect()
toMatch = n.encode('ascii', 'ignore').lower()
top = nfldb.player_search(db, n, limit=10)
matches = list()
for player, dist in top:
if player.position is not types.Enums.player_pos.UNK:
if player.first_name.lower(
) in toMatch and player.last_name.lower() in toMatch:
matches.append(player.full_name)
if len(matches) > 0:
return matches[0]
return "PLAYER_NOT_FOUND"
def save_punt_data():
print('Getting punt data from NFLDB')
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year__ge=2005).game(season_type='Regular')
all_plays = q.sort('gsis_id').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
print('Saving punt data to CSV')
df = pd.DataFrame(punts)
df.to_csv(filename)
def main(season_year):
db = nfldb.connect()
q = nfldb.Query(db).game(season_year=season_year, season_type='Postseason')
team_file = 'playoff_' + str(season_year + 1) + '_team_master.json'
with open(team_file) as f:
teams = json.load(f)
point_file = 'playoff_' + str(season_year + 1) + '_point_key.json'
with open(point_file) as f:
point_key = json.load(f)
add_points_to_teams(db, teams, point_key, write_time=False)
write_json(teams,
write_dir='teams_' + str(season_year + 1),
write_time=False)
def getOpponent(team_input, week_input):
statJSON = {}
STAT_STRING_OPPONENT = [
'passing_yds', 'passing_tds', 'rushing_yds', 'receiving_yds',
'receiving_tds', 'kickret_tds', 'fumbles_rec_tds', 'rushing_tds'
]
stat_string_list = STAT_STRING_OPPONENT
stat_season_totals = [0 for x in range(len(stat_string_list))]
#stat_string_list = ['puntret_tds']
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2012,
season_type='Regular',
week=week_input,
team=team_input)
#check for bye week all stats = 0
if len(q.as_games()) == 0:
team_home_away = 'bye'
statJSON['opponent'] = 'bye'
for index in xrange(len(stat_string_list)):
statJSON[stat_string_list[index] + '_allowed'] = 0
return statJSON
for p in q.as_games():
if p.away_team == team_input:
opponent = p.home_team
else:
opponent = p.away_team
statJSON['opponent'] = opponent
#print "Team: ", team_input, " has Opponent: ", opponent
q.game(season_year=2012,
season_type='Regular',
week=week_input,
team=opponent)
for p in q.as_games():
for index in xrange(len(stat_string_list)):
stat = showStat(stat_string_list[index], opponent, week_input)
statJSON[stat_string_list[index] + '_allowed'] = stat
stat_season_totals[index] += stat
#print statJSON
return statJSON
def getWR():
print "\n\n-------------------------- TOP WRs --------------------------"
receivers = {}
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2015, season_type='Regular')
for pp in q.sort('receiving_yds').limit(50).as_aggregate():
if str(pp.player) not in receivers and str(pp.player)[-3:-1] == 'WR':
receivers[str(pp.player)] = calcFantasyScorePositional(pp)
# for player in receivers:
# print player, receivers.get(player)
receivers = getTop25(receivers)
print len(receivers)
return receivers
def getWR():
print "\n\n-------------------------- TOP WRs --------------------------"
receivers = {}
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2015, season_type='Regular')
for pp in q.sort('receiving_yds').limit(50).as_aggregate():
if str(pp.player) not in receivers and str(pp.player)[-3:-1] == 'WR':
receivers[str(pp.player)] = calcFantasyScorePositional(pp)
# for player in receivers:
# print player, receivers.get(player)
receivers = getTop25(receivers)
print len(receivers)
return receivers
def getRB():
print "\n\n-------------------------- TOP RBs --------------------------"
runningbacks = {}
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2015, season_type='Regular')
for pp in q.sort('rushing_yds').limit(50).as_aggregate():
if str(pp.player) not in runningbacks and str(pp.player)[-3:-1]== 'RB':
runningbacks[str(pp.player)] = calcFantasyScorePositional(pp)
# for player in runningbacks:
# print player, runningbacks.get(player)
runningbacks = getTop25(runningbacks)
print len(runningbacks)
return runningbacks
def search_player(request):
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
db = nfldb.connect()
s_position = form.cleaned_data['position']
s_name = form.cleaned_data['full_name']
s_team = form.cleaned_data['team']
player = None
if s_team == 'None' and s_position == 'None':
players = Player.objects.filter(full_name__contains=s_name)
player, s_score = nfldb.player_search(db, s_name)
#print 'Similarity score: %d, Player: %s' % (s_score, players)
elif s_name == '' and s_position == 'None':
players = Player.objects.filter(team=s_team)
elif s_team == 'None' and s_name == '':
players = Player.objects.filter(position=s_position)
elif s_team == 'None':
players = Player.objects.filter(position=s_position,
full_name__contains=s_name)
player, s_score = nfldb.player_search(db, s_name)
else:
players = Player.objects.filter(team=s_team,
position=s_position,
full_name__contains=s_name)
player, s_score = nfldb.player_search(db, s_name)
if len(players) == 1:
link_id = player.player_id
link_s = '/players/'
link = link_s + link_id
return HttpResponseRedirect(link)
return render(request, "search_player.html", {
'form': form,
'players': players,
'player': player
})
else:
form = SearchForm()
return render(request, "search_player.html", {'form': form})
def getTE():
print "\n\n-------------------------- TOP TEs --------------------------"
tightends = {}
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2015, season_type='Regular')
for pp in q.sort('receiving_yds').limit(130).as_aggregate():
if str(pp.player) not in tightends and str(pp.player)[-3:-1] == 'TE':
tightends[str(pp.player)] = calcFantasyScorePositional(pp)
# for player in tightends:
# print player, tightends.get(player)
tightends = getTop25(tightends)
print len(tightends)
return tightends
def getQB():
print "\n\n-------------------------- TOP QBs --------------------------"
quarterbacks = {}
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2015, season_type='Regular')
for pp in q.sort('passing_yds').limit(50).as_aggregate():
if str(pp.player) not in quarterbacks and str(pp.player)[-3:-1] == 'QB':
quarterbacks[str(pp.player)] = calcFantasyScorePositional(pp)
# for player in quarterbacks:
# print player, quarterbacks.get(player)
quarterbacks = getTop25(quarterbacks)
print len(quarterbacks)
return quarterbacks
def getTE():
print "\n\n-------------------------- TOP TEs --------------------------"
tightends = {}
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2015, season_type='Regular')
for pp in q.sort('receiving_yds').limit(130).as_aggregate():
if str(pp.player) not in tightends and str(pp.player)[-3:-1] == 'TE':
tightends[str(pp.player)] = calcFantasyScorePositional(pp)
# for player in tightends:
# print player, tightends.get(player)
tightends = getTop25(tightends)
print len(tightends)
return tightends
def main():
global db, conf
p = argparse.ArgumentParser(
description='Run the NFLfan web interface.')
p.add_argument('--config', metavar='DIR', default='',
help='Configuration directory.')
p.add_argument('--debug', action='store_true',
help='Enable Bottle\'s debug mode.')
p.add_argument('--reload', action='store_true',
help='Enable Bottle\'s reloading functionality.')
p.add_argument('--port', type=int, default=8080)
p.add_argument('--host', default='localhost')
p.add_argument('--server', default='wsgiref',
help='The web server to use. You only need to change this '
'if you\'re running a production server.')
p.add_argument('--available-servers', action='store_true',
help='Shows list of available web server names and quits.')
args = p.parse_args()
if args.available_servers:
for name in sorted(bottle.server_names):
try:
__import__(name)
print(name)
except:
pass
sys.exit(0)
bottle.TEMPLATE_PATH.insert(0, path.join(web_path, 'tpl'))
db = nfldb.connect()
conf = nflfan.load_config(providers=nflfan.builtin_providers,
file_path=args.config)
builtins['db'] = db
builtins['conf'] = conf
bottle.install(exec_time)
bottle.run(server=args.server, host=args.host, port=args.port,
debug=args.debug, reloader=args.reload)
def plyrStatsPull(adpPlyrId, minAdpPlayer, pos, year):
attrib = {}
score = {}
db = nfldb.connect()
player, _ = nfldb.player_search(db, minAdpPlayer, position=pos)
q = nfldb.Query(db)
q.player(player_id=player.player_id)
q.game(season_year=year, season_type='Regular')
for pp in q.as_aggregate():
score['passYds'] = pp.passing_yds
score['passTd'] = pp.passing_tds
score['passInt'] = pp.passing_int
score['pass2pt'] = pp.passing_twoptm
score['rushYds'] = pp.rushing_yds
score['rushTd'] = pp.rushing_tds
score['rush2pt'] = pp.rushing_twoptm
score['recYds'] = pp.receiving_yds
score['recTd'] = pp.receiving_tds
score['rec2pt'] = pp.receiving_twoptm
score['recRec'] = pp.receiving_rec
score['kRetTd'] = pp.kickret_tds
score['pRetTd'] = pp.puntret_tds
score['fumRecTd'] = pp.fumbles_rec_tds
score['fumLost'] = pp.fumbles_lost
attrib['pos'] = pos
attrib['team'] = player.team
attrib['playerName'] = minAdpPlayer
plyrIdx = adpPlyrId
df1 = pd.DataFrame(score, index=[plyrIdx])
df1 = df1[[
'passTd', 'passYds', 'passInt', 'pass2pt', 'rushTd', 'rushYds',
'rush2pt', 'recTd', 'recYds', 'rec2pt', 'recRec', 'kRetTd', 'pRetTd',
'fumRecTd', 'fumLost'
]]
return df1
def nfldb_playerquery(self, msg, matches):
args = matches.group(1)
parser = argparse.ArgumentParser(description='Query the nfldb for stats', prog="!nfl playerquery")
parser.add_argument('-w','--week', dest='week', metavar="WEEK", type=int, help="Week to query")
parser.add_argument('-y','--year', dest='year', metavar="YEAR", type=int, default=2014, help="Year to query")
parser.add_argument('-p','--position', dest='position', metavar="POSITION", help="Position to query")
parser.add_argument('-s','--stat', dest='stat', metavar="STAT", help="Stat to query")
parser.add_argument('-c','--count', dest='count', metavar="COUNT", type=int, default=5, help="How many results to return (Max: 20)")
parser.add_argument('-t','--team', dest='team', metavar="TEAM", help="Team to query, use short name i.e. NE")
pargs = parser.parse_args(args.split())
print(pargs)
if pargs.position == None and pargs.stat == None:
return "Either position, stat, or both must be specified"
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=pargs.year)
if pargs.position:
q.player(position=pargs.position)
if pargs.team:
q.game(team=pargs.team)
if pargs.stat:
q.sort(pargs.stat)
text = "Results:\n"
for pp in q.limit(pargs.count).as_aggregate():
text += "{}: {}\n".format(pp.player, getattr(pp, pargs.stat))
return text
def doit():
log('-' * 79)
log('STARTING NFLDB UPDATE AT %s' % now())
log('Connecting to nfldb... ', end='')
db = nfldb.connect()
log('done.')
# We always insert dates and times as UTC.
log('Setting timezone to UTC... ', end='')
nfldb.set_timezone(db, 'UTC')
log('done.')
if update_turnovers:
update_game_turnovers(db, update_turnovers)
elif update_schedules:
update_game_schedules(db)
elif simulate is not None:
done = update_simulate(db)
if done:
log('Simulation complete.')
return True
else:
with nfldb.Tx(db) as cursor:
# Update players first. This is important because if an unknown
# player is discovered in the game data, the player will be
# upserted. We'd like to avoid that because it's slow.
update_players(cursor, player_interval)
# Now update games.
update_games(db, batch_size=batch_size)
log('Closing database connection... ', end='')
db.close()
log('done.')
log('FINISHED NFLDB UPDATE AT %s' % now())
log('-' * 79)
def five_qb_list(request):
if request.method == "POST":
return HttpResponse('Cannot POST.')
if request.method == "GET":
qbs = {}
qbs['passing'] = []
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2017, season_type='Regular')
for g in q.sort('passing_yds').limit(5).as_aggregate():
qbs['passing'] += [{
'id': g.player.player_id,
'name': g.player.full_name,
'yds': g.passing_yds,
}]
# print(g)
# qbs = serializers.serialize(qbs)
# return JsonResponse(qbs)
# return HttpResponse(players, content_type="application/json")
return render(request, "top.html", {'pass_list': qbs['passing']})
else:
return HttpResponse("404")
def __init__(self, name, **keyword_params):
super(QuarterbackStats, self).__init__()
db = nfldb.connect()
q = nfldb.Query(db)
#case for carrer or yearly stats
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='QB')
stats = q.as_aggregate()
if len(stats) > 0:
stats = stats[0]
self.passing_att = stats.passing_att
self.passing_cmp = stats.passing_cmp
self.passing_incmp = stats.passing_incmp
self.passing_yds = stats.passing_yds
self.passing_incmp_air_yds = stats.passing_incmp_air_yds
self.passing_cmp_air_yds = stats.passing_cmp_air_yds
self.passing_tds = stats.passing_tds
self.passing_int = stats.passing_int
self.passing_sk = stats.passing_sk
self.rushing_att = stats.rushing_att
self.rushing_yds = stats.rushing_yds
self.rushing_tds = stats.rushing_tds
self.fumbles_tot = stats.fumbles_tot
self.fumbles_lost = stats.fumbles_lost
def showStatDefense(team_input, week_input):
statJSON = {}
#STAT_STRING_LIST_DEFENSE=['defense_sk', 'defense_int', 'defense_frec', 'defense_safe', 'defense_frec_tds', 'defense_int_tds', 'defense_misc_tds', 'kickret_tds']
stat_string_list = STAT_STRING_LIST_DEFENSE
stat_season_totals = [0 for x in range(len(stat_string_list))]
#stat_string_list = ['puntret_tds']
db = nfldb.connect()
q = nfldb.Query(db)
q.game(season_year=2012,
season_type='Regular',
week=week_input,
team=team_input)
for p in q.as_games():
if p.away_team == team_input:
statJSON['points_allowed'] = p.home_score
else:
statJSON['points_allowed'] = p.away_score
#check for bye week all stats = 0
if len(q.as_games()) == 0:
team_home_away = 'bye'
for index in xrange(len(stat_string_list)):
statJSON[stat_string_list[index]] = 0
return statJSON
for index in xrange(len(stat_string_list)):
stat = showStat(stat_string_list[index], team_input, week_input)
statJSON[stat_string_list[index]] = stat
#stat_season_totals[index] +=stat
statJSON['defense_touchdowns'] = statJSON['defense_int_tds'] + statJSON[
'defense_frec_tds'] + statJSON['defense_misc_tds']
# for key, index in statJSON.items():
#print ("Totals Week: " +str(week_input) + " " + team_input + " " + key+ " "+ str(index) + '\n')
return statJSON
