def _run_active(callback, games):
"""
The active mode traverses each of the active games and fetches info for
each from NFL.com.
Then each game (that has info available on NFL.com---that is, the game
has started) is added to one of two lists: active and completed, which
are passed as the first and second parameters to callback. A game is
put in the active list if it's still being played, and into the completed
list if it has finished. In the latter case, it is added to a global store
of completed games and will never be passed to callback again.
"""
# There are no active games, so just quit and return False. Which means
# we'll transition to inactive mode.
if len(games) == 0:
return False
active, completed = [], []
for info in games:
game = nflgame.game.Game(info['eid'])
# If no JSON was retrieved, then we're probably just a little early.
# So just ignore it for now---but we'll keep trying!
if game is None:
continue
# If the game is over, added it to completed and _completed.
if game.game_over():
completed.append(game)
_completed.append(info['eid'])
else:
active.append(game)
callback(active, completed)
return True
def _run_active(callback, games):
"""
The active mode traverses each of the active games and fetches info for
each from NFL.com.
Then each game (that has info available on NFL.com---that is, the game
has started) is added to one of two lists: active and completed, which
are passed as the first and second parameters to callback. A game is
put in the active list if it's still being played, and into the completed
list if it has finished. In the latter case, it is added to a global store
of completed games and will never be passed to callback again.
"""
# There are no active games, so just quit and return False. Which means
# we'll transition to inactive mode.
if len(games) == 0:
return False
active, completed = [], []
for info in games:
game = nflgame.game.Game(info['eid'])
# If no JSON was retrieved, then we're probably just a little early.
# So just ignore it for now---but we'll keep trying!
if game is None:
continue
# If the game is over, added it to completed and _completed.
if game.game_over():
completed.append(game)
_completed.append(info['eid'])
else:
active.append(game)
callback(active, completed)
return True
def _run_active(callback, games):
"""
The active mode traverses each of the active games and fetches info for
each from NFL.com.
Then each game is added to one of two lists: active and completed, which
are passed as the first and second parameters to callback. A game is
put in the active list if it's still being played, or a bout to play
and into the completed list if it has finished. In the latter case,
it is added to a global store of completed games and will never be
passed to callback again.
"""
global _last
# There are no active games, so just quit and return False. Which means
# we'll transition to inactive mode.
if len(games) == 0:
return False
active, completed = [], []
for info in games:
game = nflgame.game.Game(info['eid'])
# If no JSON was retrieved, then we're probably just a little early.
# So just ignore it for now---but we'll keep trying!
if game is None:
continue
# If the game is over, added it to completed and _completed.
if game.game_over():
completed.append(game)
_completed.append(info['eid'])
else:
active.append(game)
# Create a list of game diffs between the active + completed games and
# whatever is in _last.
diffs = []
for game in active + completed:
for last_game in _last or []:
if game.eid != last_game.eid or not game.gcJsonAvailable:
continue
diffs.append(game - last_game)
_last = active
callback(active, completed, diffs)
return True
def run(callback, active_interval=15, inactive_interval=900, stop=None):
"""
Starts checking for games that are currently playing.
Every time there is an update, callback will be called with three
lists: active, completed and diffs. The active list is a list of
game.Game that are currently being played. The completed list is
a list of game.Game that have just finished. The diffs list is a
list of `nflgame.game.GameDiff` objects, which collects statistics
that are new since the last time `callback` was called. A game will
appear in the completed list only once, after which that game will
not be in either the active or completed lists. No game can ever
be in both the `active` and `completed` lists at the same time.
It is possible that a game in the active list is not yet playing because
it hasn't started yet. It ends up in the active list because the "pregame"
has started on NFL.com's GameCenter web site, and sometimes game data is
partially filled. When this is the case, the 'playing' method on
a nflgame.game.Game will return False.
When in the active mode (see live module description), active_interval
specifies the number of seconds to wait between checking for updated game
data. Please do not make this number too low to avoid angering NFL.com.
If you anger them too much, it is possible that they could ban your IP
address.
Note that NFL.com's GameCenter page is updated every 15 seconds, so
setting the active_interval much smaller than that is wasteful.
When in the inactive mode (see live module description), inactive_interval
specifies the number of seconds to wait between checking whether any games
have started or are about to start.
With the default parameters, run will never stop. However, you may set
stop to a Python datetime.datetime value. After time passes the stopping
point, run will quit. (Technically, it's possible that it won't quit until
at most inactive_interval seconds after the stopping point is reached.)
The stop value is compared against datetime.datetime.now().
"""
active = False
last_week_check = _update_week_number()
# Before we start with the main loop, we make a first pass at what we
# believe to be the active games. Of those, we check to see if any of
# them are actually already over, and add them to _completed.
for info in _active_games(inactive_interval):
game = nflgame.game.Game(info['eid'])
# If we couldn't get a game, that probably means the JSON feed
# isn't available yet. (i.e., we're early.)
if game is None:
continue
# Otherwise, if the game is over, add it to our list of completed
# games and move on.
if game.game_over():
_completed.append(info['eid'])
while True:
if stop is not None and datetime.datetime.now() > stop:
return
if time.time() - last_week_check > _WEEK_INTERVAL:
last_week_check = _update_week_number()
games = _active_games(inactive_interval)
if active:
active = _run_active(callback, games)
if not active:
continue
time.sleep(active_interval)
else:
active = not _run_inactive(games)
if active:
continue
time.sleep(inactive_interval)
def run(callback, active_interval=15, inactive_interval=900, stop=None):
"""
Starts checking for games that are currently playing.
Every time there is an update, callback will be called with three
lists: active, completed and diffs. The active list is a list of
game.Game that are currently being played. The completed list is
a list of game.Game that have just finished. The diffs list is a
list of `nflgame.game.GameDiff` objects, which collects statistics
that are new since the last time `callback` was called. A game will
appear in the completed list only once, after which that game will
not be in either the active or completed lists. No game can ever
be in both the `active` and `completed` lists at the same time.
It is possible that a game in the active list is not yet playing because
it hasn't started yet. It ends up in the active list because the "pregame"
has started on NFL.com's GameCenter web site, and sometimes game data is
partially filled. When this is the case, the 'playing' method on
a nflgame.game.Game will return False.
When in the active mode (see live module description), active_interval
specifies the number of seconds to wait between checking for updated game
data. Please do not make this number too low to avoid angering NFL.com.
If you anger them too much, it is possible that they could ban your IP
address.
Note that NFL.com's GameCenter page is updated every 15 seconds, so
setting the active_interval much smaller than that is wasteful.
When in the inactive mode (see live module description), inactive_interval
specifies the number of seconds to wait between checking whether any games
have started or are about to start.
With the default parameters, run will never stop. However, you may set
stop to a Python datetime.datetime value. After time passes the stopping
point, run will quit. (Technically, it's possible that it won't quit until
at most inactive_interval seconds after the stopping point is reached.)
The stop value is compared against datetime.datetime.now().
"""
active = False
last_week_check = _update_week_number()
# Before we start with the main loop, we make a first pass at what we
# believe to be the active games. Of those, we check to see if any of
# them are actually already over, and add them to _completed.
for info in _active_games(inactive_interval):
game = nflgame.game.Game(info['eid'])
# If we couldn't get a game, that probably means the JSON feed
# isn't available yet. (i.e., we're early.)
if game is None:
continue
# Otherwise, if the game is over, add it to our list of completed
# games and move on.
if game.game_over():
_completed.append(info['eid'])
while True:
if stop is not None and datetime.datetime.now() > stop:
return
if time.time() - last_week_check > _WEEK_INTERVAL:
last_week_check = _update_week_number()
games = _active_games(inactive_interval)
if active:
active = _run_active(callback, games)
if not active:
continue
time.sleep(active_interval)
else:
active = not _run_inactive(games)
if active:
continue
time.sleep(inactive_interval)
