Package nflgame :: Module player
[frames] | no frames]

Source Code for Module nflgame.player

  1  import json 
  2  import os.path 
  3   
  4  from nflgame import OrderedDict 
  5  import nflgame.seq 
  6  import nflgame.statmap 
7 8 9 -def _create_players(jsonf=None):
10 """ 11 Creates a dict of Player objects from the players.json file, keyed 12 by GSIS ids. 13 """ 14 if jsonf is None: 15 jsonf = os.path.join(os.path.split(__file__)[0], 'players.json') 16 data = json.loads(open(jsonf).read()) 17 18 players = {} 19 for playerid in data: 20 players[playerid] = Player(data[playerid]) 21 return players
22
23 24 -class Player (object):
25 """ 26 Player instances represent meta information about a single player. 27 This information includes name, team, position, status, height, 28 weight, college, jersey number, birth date, years, pro, etc. 29 30 Player information is populated from NFL.com profile pages. 31 """
32 - def __init__(self, data):
33 self.playerid = data['gsisid'] 34 self.name = data['name'] 35 self.team = data['team'] 36 self.position = data['position'] 37 self.profile_url = data['profile_url'] 38 self.number = data['number'] 39 self.status = data['status'] 40 self.weight = data['weight'] 41 self.height = data['height'] 42 self.college = data['college'] 43 self.years_pro = data['years_pro'] 44 self.birthdate = data['birthdate']
45
46 - def stats(self, year, week=None):
47 games = nflgame.games(year, week) 48 players = nflgame.combine(games).filter(playerid=self.playerid) 49 return list(players)[0]
50
51 - def plays(self, year, week=None):
52 plays = [] 53 games = nflgame.games(year, week) 54 for g in games: 55 plays += filter(lambda p: p.has_player(self.playerid), 56 list(g.drives.plays())) 57 return nflgame.seq.GenPlays(plays)
58
59 - def __str__(self):
60 return '%s (%s, %s)' % (self.name, self.position, self.team)
61
62 63 -class PlayerDefense (Player):
64 - def __init__(self, team):
65 self.playerid = None 66 self.name = team 67 self.team = team 68 self.position = 'DEF'
69
70 - def stats(self, year, week=None):
71 assert False, 'Cannot be called on a defense.'
72
73 - def plays(self, year, week=None):
74 assert False, 'Cannot be called on a defense.'
75
76 - def __str__(self):
77 return '%s Defense' % self.team
78
79 80 -class PlayerStats (object):
81 """ 82 Player represents a single player and all of his statistical categories. 83 Every player has 'playerid', 'name' and 'home' fields. 84 Additionally, depending upon which statistical categories that player 85 was involved in for the game, he'll have properties such as 'passing_tds', 86 'rushing_yds', 'defense_int' and 'kicking_fgm'. 87 88 In order to know whether a paricular player belongs to a statical category, 89 you may use the filtering methods of a player sequence or alternatively, 90 use the has_cat method with arguments like 'passing', 'rushing', 'kicking', 91 etc. (A player sequence in this case would be an instance of 92 GenPlayerStats.) 93 94 You may also inspect whether a player has a certain property by using 95 the special __dict__ attribute. For example:: 96 97 if 'passing_yds' in player.__dict__: 98 # Do something with player.passing_yds 99 """
100 - def __init__(self, playerid, name, home, team):
101 """ 102 Create a new Player instance with the player id (from NFL.com's 103 GameCenter), the player's name (e.g., "T.Brady") and whether the 104 player is playing in a home game or not. 105 """ 106 self.playerid = playerid 107 self.name = name 108 self.home = home 109 self.team = team 110 self._stats = OrderedDict() 111 112 self.player = None 113 if self.playerid in nflgame.players: 114 self.player = nflgame.players[self.playerid]
115
116 - def has_cat(self, cat):
117 for f in self._stats: 118 if f.startswith(cat): 119 return True 120 return False
121 122 @property
123 - def tds(self):
124 """ 125 Returns the total number of touchdowns credited to this player across 126 all statistical categories. 127 """ 128 n = 0 129 for f, v in self.__dict__.iteritems(): 130 if f.endswith('tds'): 131 n += v 132 return n
133 134 @property
135 - def twopta(self):
136 """ 137 Returns the total number of two point conversion attempts for 138 the passing, rushing and receiving categories. 139 """ 140 return (self.passing_twopta 141 + self.rushing_twopta 142 + self.receiving_twopta)
143 144 @property
145 - def twoptm(self):
146 """ 147 Returns the total number of two point conversions for 148 the passing, rushing and receiving categories. 149 """ 150 return (self.passing_twoptm 151 + self.rushing_twoptm 152 + self.receiving_twoptm)
153 154 @property
155 - def twoptmissed(self):
156 """ 157 Returns the total number of two point conversion failures for 158 the passing, rushing and receiving categories. 159 """ 160 return (self.passing_twoptmissed 161 + self.rushing_twoptmissed 162 + self.receiving_twoptmissed)
163 164 @property
165 - def stats(self):
166 """ 167 Returns a dict of all stats for the player. 168 """ 169 return self._stats
170
171 - def formatted_stats(self):
172 """ 173 Returns a roughly-formatted string of all statistics for this player. 174 """ 175 s = [] 176 for stat, val in self._stats.iteritems(): 177 s.append('%s: %s' % (stat, val)) 178 return ', '.join(s)
179
180 - def _add_stats(self, stats):
181 for k, v in stats.iteritems(): 182 self.__dict__[k] = self.__dict__.get(k, 0) + v 183 self._stats[k] = self.__dict__[k]
184
185 - def _overwrite_stats(self, stats):
186 for k, v in stats.iteritems(): 187 self.__dict__[k] = v 188 self._stats[k] = self.__dict__[k]
189
190 - def __str__(self):
191 """ 192 Simply returns the player's name, e.g., "T.Brady". 193 """ 194 return self.name
195
196 - def __add__(self, other):
197 """ 198 Adds two players together. Only two player objects that correspond 199 to the same human (i.e., GameCenter identifier) can be added together. 200 201 If two different players are added together, an assertion will 202 be raised. 203 204 The effect of adding two player objects simply corresponds to the 205 sums of all statistical values. 206 207 Note that as soon as two players have been added, the 'home' property 208 becomes undefined if the two operands have different values of 'home'. 209 """ 210 assert self.playerid == other.playerid 211 assert type(self) == type(other) 212 213 if self.home != other.home: 214 home = None 215 else: 216 home = self.home 217 new_player = self.__class__(self.playerid, self.name, home, self.team) 218 new_player._add_stats(self._stats) 219 new_player._add_stats(other._stats) 220 221 return new_player
222
223 - def __sub__(self, other):
224 assert self.playerid == other.playerid 225 assert type(self) == type(other) 226 227 new_player = GamePlayerStats(self.playerid, 228 self.name, self.home, self.team) 229 new_player._add_stats(self._stats) 230 for bk, bv in other._stats.iteritems(): 231 if bk not in new_player._stats: # stat was taken away? ignore. 232 continue 233 234 new_player._stats[bk] -= bv 235 if new_player._stats[bk] == 0: 236 del new_player._stats[bk] 237 else: 238 new_player.__dict__[bk] = new_player._stats[bk] 239 240 anydiffs = False 241 for k, v in new_player._stats.iteritems(): 242 if v > 0: 243 anydiffs = True 244 break 245 if not anydiffs: 246 return None 247 return new_player
248
249 - def __getattr__(self, name):
250 # If name has one of the categories as a prefix, then return 251 # a default value of zero 252 for cat in nflgame.statmap.categories: 253 if name.startswith(cat): 254 return 0 255 print name 256 raise AttributeError
257
258 259 -class GamePlayerStats (PlayerStats):
260 - def __init__(self, playerid, name, home, team):
261 super(GamePlayerStats, self).__init__(playerid, name, home, team) 262 self.games = 1
263
264 - def __add__(self, other):
265 new_player = super(GamePlayerStats, self).__add__(other) 266 new_player.games = self.games + other.games 267 return new_player
268
269 270 -class PlayPlayerStats (PlayerStats):
271 pass
272