1 import json
2 import os.path
3
4 from nflgame import OrderedDict
5 import nflgame.seq
6 import nflgame.statmap
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
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 """
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):
50
51 - def plays(self, year, week=None):
58
60 return '%s (%s, %s)' % (self.name, self.position, self.team)
61
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
77 return '%s Defense' % self.team
78
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
117 for f in self._stats:
118 if f.startswith(cat):
119 return True
120 return False
121
122 @property
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
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
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
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
166 """
167 Returns a dict of all stats for the player.
168 """
169 return self._stats
170
179
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
186 for k, v in stats.iteritems():
187 self.__dict__[k] = v
188 self._stats[k] = self.__dict__[k]
189
191 """
192 Simply returns the player's name, e.g., "T.Brady".
193 """
194 return self.name
195
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
224 assert self.playerid == other.playerid
225 assert type(self) == type(other)
226
227 new_player = GamePlayerStats(self.playerid, self.name, self.home)
228 new_player._add_stats(self._stats)
229 for bk, bv in other._stats.iteritems():
230 if bk not in new_player._stats:
231 continue
232
233 new_player._stats[bk] -= bv
234 if new_player._stats[bk] == 0:
235 del new_player._stats[bk]
236 else:
237 new_player.__dict__[bk] = new_player._stats[bk]
238
239 anydiffs = False
240 for k, v in new_player._stats.iteritems():
241 if v > 0:
242 anydiffs = True
243 break
244 if not anydiffs:
245 return None
246 return new_player
247
256
259 - def __init__(self, playerid, name, home, team):
262
267
271