def player_search(db, full_name, team=None, position=None):
"""
A thin wrapper around `nfldb.player_search` that tries searching
with `team` or `position` when given, but if no results are found,
then this returns the results of a search with just the full name.
This allows for a slightly out-of-date database to still provide
a match while also disambiguating players with the same name.
"""
if position not in nfldb.Enums.player_pos:
position = None
p, _ = nfldb.player_search(db, full_name, team=team, position=position)
if p is None and position is not None:
p, _ = nfldb.player_search(db, full_name, team=team, position=None)
if p is None and team is not None:
p, _ = nfldb.player_search(db, full_name, team=None, position=position)
if p is None and team is not None and position is not None:
p, _ = nfldb.player_search(db, full_name, team=None, position=None)
return p
def player_search(db, full_name, team=None, position=None):
"""
A thin wrapper around `nfldb.player_search` that tries searching
with `team` or `position` when given, but if no results are found,
then this returns the results of a search with just the full name.
This allows for a slightly out-of-date database to still provide
a match while also disambiguating players with the same name.
"""
if position not in nfldb.Enums.player_pos:
position = None
p, _ = nfldb.player_search(db, full_name, team=team, position=position)
if p is None and position is not None:
p, _ = nfldb.player_search(db, full_name, team=team, position=None)
if p is None and team is not None:
p, _ = nfldb.player_search(db, full_name, team=None, position=position)
if p is None and team is not None and position is not None:
p, _ = nfldb.player_search(db, full_name, team=None, position=None)
return p
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 search_player():
name = request.args.get('name')
player_list = []
player, dist = nfldb.player_search(db, name)
data = {
'label': player.full_name + " (" + player.team + ", " + str(player.position) + ")",
'value': player.full_name,
'id': player.player_id,
}
player_list.append(data)
return jsonify(matching_results=player_list)
def _player_lookup(player, conn):
try:
q = Query(conn)
p = q.player(full_name=player).as_players()
if len(p) == 1:
return p[0].full_name, p[0].player_id
else:
similar = "\n\t* ".join(x[0].full_name
for x in player_search(conn, s, limit=3))
msg = "{0} could not be found in player DB. Similar results:\n\t* {1}".format(
s, similar)
raise Exception(msg)
except Exception as e:
raise Exception(
"Error looking up names, details follow. {0}".format(e))
def search(db, name, team, pos, soundex=False):
"""
Provides a thin wrapper over nfldb's player search. Namely, if
`name` is one word, then it assumes that it's a first/last name and
tries to match it exactly against the list of results returned from
the Levenshtein/Soundex search.
"""
matches = nfldb.player_search(db, name, team, pos,
limit=100, soundex=soundex)
if len(matches) == 0:
return None
if ' ' not in name:
for p, _ in matches:
if name.lower() in map(str.lower, [p.first_name, p.last_name]):
return p
return matches[0][0]
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 load_dk_data(self, week, year, file_name=None, db=None):
if file_name is None:
file_name = '../data/draftkings/rotoguru/week' + str(week) + '.csv'
if db is None:
db = self.db
cur = db.cursor()
players = []
with open(file_name, 'r') as f:
header = f.readline().strip().split(';')
header = map(lambda h:h.lower().replace(' ', '_').replace('"', ''), header)
for line in f:
vals = line.rstrip().replace('"', '').split(';')
vals = map(lambda v: try_num(v), vals)
kwargs = dict([(h, vals[i] if i < len(vals) else 0.0) for i,h in enumerate(header)])
if (kwargs.get('name') is not None and kwargs.get('dk_salary') is not None):
players.append(kwargs)
print(kwargs)
for player in players:
if not isinstance(player['dk_salary'], float):
print("no salary?", player)
continue
if player['pos'].lower() != 'def':
continue
player_match = nfldb.player_search(self.db, self.get_name(player['name']))
if player_match[0] is not None:
print(player_match[0].player_id, player_match[0].first_name, player_match[0].last_name)
self.update_dk_salary(cur, player_match[0].player_id, player['dk_salary'], week, year)
print("updated", player['dk_salary'])
else:
# team defense
team = self.get_team(player['team'])
player_id = team
if len(team) == 2:
player_id = '00-00000' + team
elif len(team) == 3:
player_id = '00-0000' + team
self.update_dk_salary(cur, player_id, player['dk_salary'], week, year)
print(team, player_id, player['dk_salary'])
db.commit()
cur.close()
def match_or_raise(db, full_name, **kwargs):
"""
Lookup `full_name` in `player` table.
If not found, print similarity table and raise `KeyError`.
Otherwise, return the `player_id`.
Optional keyword arguments are passed to `nfldb.player_search`.
"""
kwargs['limit'] = kwargs.get('limit', DEFAULT_SEARCH_LIMIT)
matches = player_search(db, full_name, **kwargs)
best_match, distance = matches[0]
if not distance:
return best_match.player_id
error("""\
Player "{}" not found. Closest matches:
{}
Use nfldbproj.add_name_disambiguations to insert correct player_id into the database.""".format(
full_name, _similarity_search_table(matches)
))
raise KeyError('{} (see message above traceback)'.format(full_name))
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 match_or_raise(db, full_name, **kwargs):
"""
Lookup `full_name` in `player` table.
If not found, print similarity table and raise `KeyError`.
Otherwise, return the `player_id`.
Optional keyword arguments are passed to `nfldb.player_search`.
"""
kwargs["limit"] = kwargs.get("limit", DEFAULT_SEARCH_LIMIT)
matches = player_search(db, full_name, **kwargs)
best_match, distance = matches[0]
if not distance:
return best_match.player_id
error(
"""\
Player "{}" not found. Closest matches:
{}
Use nfldbproj.add_name_disambiguations to insert correct player_id into the database.""".format(
full_name, _similarity_search_table(matches)
)
)
raise KeyError("{} (see message above traceback)".format(full_name))
def fuzzy_search(name, limit=1, team=None, position=None):
return nfldb.player_search(dbc, name, limit=limit, team=team, position=position)
def fuzzy_search(name):
return nfldb.player_search(dbc, name, limit=30, team=None, position=None)
def searchPlayer(player_name, position_name): db = nfldb.connect() player, dist = nfldb.player_search(db, player_name, position=position_name) print 'Similarity score: %d, Player: %s' % (dist, player) return player
def searchPlayer(player_name, position_name): db = nfldb.connect() player, dist = nfldb.player_search(db, player_name, position=position_name) # print 'Similarity score: %d, Player: %s' % (dist, player) return player
def compare_players(request):
if request.method == 'POST':
form = CompareForm(request.POST)
if form.is_valid():
db = nfldb.connect()
seas_year = 2017
weeks = []
passydperweek1 = {}
passydperweek2 = {}
s_position = form.cleaned_data['position']
s_player1 = form.cleaned_data['full_name_1']
s_player2 = form.cleaned_data['full_name_2']
players = Player.objects.exclude(
team='UNK') & Player.objects.filter(position=s_position)
player1, s_score1 = nfldb.player_search(db, s_player1)
player2, s_score2 = nfldb.player_search(db, s_player2)
fullname1 = str(player1.full_name)
fullname2 = str(player2.full_name)
team1 = str(player1.team)
team2 = str(player2.team)
q = nfldb.Query(db)
games1 = q.game(season_year=seas_year,
season_type='Regular',
team=team1).as_games()
drives1 = q.drive(pos_team=team1).sort(
('start_time', 'asc')).as_drives()
games2 = q.game(season_year=seas_year,
season_type='Regular',
team=team2).as_games()
drives2 = q.drive(pos_team=team2).sort(
('start_time', 'asc')).as_drives()
for i in range(0, len(games1)):
if games1[i].finished:
weeks.append(games1[i].week)
for w in weeks:
passydperweek1[w] = []
passydperweek2[w] = []
weeks.sort(key=int)
#for loop for the first player.
for d in drives1:
pass_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=fullname1)
q.game(week=w)
results = q.aggregate(passing_yds__ge=0).as_aggregate()
if len(results) == 0:
continue
tfb = results[0]
pass_yds += tfb.passing_yds
for w in weeks:
if w == d.game.week:
passydperweek1[w] += [pass_yds]
for w in weeks:
passydperweek1[w] = sum(passydperweek1[w])
q2 = nfldb.Query(db)
games2 = q2.game(season_year=seas_year,
season_type='Regular',
team=team2).as_games()
drives2 = q2.drive(pos_team=team2).sort(
('start_time', 'asc')).as_drives()
#for loop for second player.
for d in drives2:
pass_yds = 0
#print d
for w in weeks:
q = nfldb.Query(db).drive(gsis_id=d.gsis_id,
drive_id=d.drive_id)
q.player(full_name=fullname2)
q.game(week=w)
results = q.aggregate(passing_yds__ge=0).as_aggregate()
if len(results) == 0:
continue
tfb = results[0]
pass_yds += tfb.passing_yds
for w in weeks:
if w == d.game.week:
passydperweek2[w] += [pass_yds]
for w in weeks:
passydperweek2[w] = sum(passydperweek2[w])
data = {
'form': form,
'player1': player1,
'player2': player2,
'weeks': weeks,
'team1': team1,
'team2': team2,
'passydperweek1': passydperweek1,
'passydperweek2': passydperweek2,
}
return render(request, "compare_players.html", {'data': data})
else:
form = CompareForm()
return render(request, "compare_players.html", {'form': form})
import nfldb
db = nfldb.connect()
player, _ = nfldb.player_search(db, 'Kareem Hunt', position='RB')
print player.player_id
q = nfldb.Query(db)
q.player(player_id=player.player_id)
for pp in q.as_aggregate():
print player.team
print pp
#for some in player:
# print some
#print player
q = nfldb.Query(db).game(season_year=2015, season_type='Regular', week=10)
res = q.aggregate(passing_yds__ge=1)
for o in res.as_aggregate():
print o.player, o.passing_yds
julio, dist = nfldb.player_search(db, 'Karlos Williams')
print 'looking for: %s' % (julio)
q1 = nfldb.Query(db).game(season_year=2015, season_type='Regular', week=10)
res1 = q1.aggregate()
for p in res1.as_aggregate():
if p.player == julio:
print p.player, o.rushing_yds
#else:
# print p.player
'''
q_player = nfldb.Query(db).game(season_year=2015, season_type='Regular', week=10, name='Julio Jones')
print 'printing Query object'
print q_player
print 'printing aggergate()'
