def __rotate_rate_for_status(self, status):
rotate_rate = self.data.config.live_rotate_rate
if Status.is_pregame(status):
rotate_rate = self.data.config.pregame_rotate_rate
if Status.is_complete(status):
rotate_rate = self.data.config.final_rotate_rate
return rotate_rate
def __draw_game(self, game, overview):
self.canvas.Fill(*ledcolors.scoreboard.fill)
# Draw the pregame renderer
if Status.is_pregame(overview.status):
pregame = Pregame(overview)
renderer = PregameRenderer(self.canvas, pregame,
self.data.config.coords["pregame"],
self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the final game renderer
elif Status.is_complete(overview.status):
final = Final(game)
scoreboard = Scoreboard(overview)
renderer = FinalRenderer(self.canvas, final, scoreboard,
self.data.config, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the scoreboar renderer
elif Status.is_irregular(overview.status):
scoreboard = Scoreboard(overview)
StatusRenderer(self.canvas, scoreboard, self.data.config).render()
else:
scoreboard = Scoreboard(overview)
ScoreboardRenderer(self.canvas, scoreboard,
self.data.config).render()
self.canvas = self.matrix.SwapOnVSync(self.canvas)
def __draw_game(self, game, overview):
color = self.data.config.scoreboard_colors.color("default.background")
self.canvas.Fill(color["r"], color["g"], color["b"])
# Draw the pregame renderer
if Status.is_pregame(overview.status):
scoreboard = Scoreboard(overview)
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("pregame.scrolling_text"))
pregame = Pregame(overview)
renderer = PregameRenderer(self.canvas, pregame, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the final game renderer
elif Status.is_complete(overview.status):
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("final.scrolling_text"))
final = Final(game)
scoreboard = Scoreboard(overview)
renderer = FinalRenderer(self.canvas, final, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the scoreboar renderer
elif Status.is_irregular(overview.status):
scoreboard = Scoreboard(overview)
if scoreboard.get_text_for_reason():
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("status.scrolling_text"))
renderer = StatusRenderer(self.canvas, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
else:
StatusRenderer(self.canvas, scoreboard, self.data).render()
else:
scoreboard = Scoreboard(overview)
ScoreboardRenderer(self.canvas, scoreboard, self.data).render()
self.canvas = self.matrix.SwapOnVSync(self.canvas)
def __rotate_rate_for_status(self, status):
rotate_rate = self.data.config.rotation_rates_live
if Status.is_pregame(status):
rotate_rate = self.data.config.rotation_rates_pregame
if Status.is_complete(status):
rotate_rate = self.data.config.rotation_rates_final
return rotate_rate
def __draw_game(self, game, overview):
color = self.data.config.scoreboard_colors.color("default.background")
self.canvas.Fill(color["r"], color["g"], color["b"])
# Draw the pregame renderer
if Status.is_pregame(overview.status):
scoreboard = Scoreboard(overview)
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("pregame.scrolling_text"))
pregame = Pregame(overview)
renderer = PregameRenderer(self.canvas, pregame, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the final game renderer
elif Status.is_complete(overview.status):
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("final.scrolling_text"))
final = Final(game)
scoreboard = Scoreboard(overview)
renderer = FinalRenderer(self.canvas, final, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the scoreboar renderer
elif Status.is_irregular(overview.status):
scoreboard = Scoreboard(overview)
if scoreboard.get_text_for_reason():
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("status.scrolling_text"))
renderer = StatusRenderer(self.canvas, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
else:
StatusRenderer(self.canvas, scoreboard, self.data).render()
else:
scoreboard = Scoreboard(overview)
ScoreboardRenderer(self.canvas, scoreboard, self.data).render()
self.canvas = self.matrix.SwapOnVSync(self.canvas)
def __rotate_rate_for_status(self, status):
rotate_rate = self.data.config.rotation_rates_live
if Status.is_pregame(status):
rotate_rate = self.data.config.rotation_rates_pregame
if Status.is_complete(status):
rotate_rate = self.data.config.rotation_rates_final
return rotate_rate
def create_statuses():
s = create_session()
api = Status(name='API user', id=0)
s.add(api)
admin = Status(name='admin', id=1)
s.add(admin)
user = Status(name='user', id=2)
s.add(user)
s.commit()
def render(self):
color = self.data.config.scoreboard_colors.color("default.background")
self.canvas.Fill(color["r"], color["g"], color["b"])
starttime = time.time()
# Main and only loop
while True:
# If we need to refresh the overview data, do that
if self.data.needs_refresh:
self.data.refresh_overview()
# Draw the current game
self.__draw_game(self.data.current_game(), self.data.overview)
# Check if we need to scroll until it's finished
if self.data.config.rotation_scroll_until_finished == False:
self.scrolling_finished = True
# Set the refresh rate
refresh_rate = self.data.config.scrolling_speed
# If we're not scrolling anything, scroll is always finished.
if Status.is_static(self.data.overview.status) and not Scoreboard(
self.data.overview).get_text_for_reason():
self.scrolling_finished = True
time.sleep(refresh_rate)
endtime = time.time()
time_delta = endtime - starttime
rotate_rate = self.__rotate_rate_for_status(
self.data.overview.status)
# If we're ready to rotate, let's do it
if time_delta >= rotate_rate and self.scrolling_finished:
starttime = time.time()
self.scrolling_finished = False
self.data.needs_refresh = True
if Status.is_fresh(self.data.overview.status):
self.scrolling_text_pos = self.canvas.width
if self.__should_rotate_to_next_game(self.data.overview):
self.scrolling_text_pos = self.canvas.width
game = self.data.advance_to_next_game()
if endtime - self.data.games_refresh_time >= GAMES_REFRESH_RATE:
self.data.refresh_games()
if self.data.needs_refresh:
self.data.refresh_overview()
if Status.is_complete(self.data.overview.status):
if Final(self.data.current_game()
).winning_pitcher == 'Unknown':
self.data.refresh_games()
def __render_game(self):
while True:
# If we need to refresh the overview data, do that
if self.data.needs_refresh:
self.data.refresh_overview()
# Draw the current game
self.__draw_game(self.data.current_game(), self.data.overview)
# Check if we need to scroll until it's finished
if self.data.config.rotation_scroll_until_finished == False:
self.scrolling_finished = True
# Set the refresh rate
refresh_rate = self.data.config.scrolling_speed
# Currently the only thing that's always static is the live scoreboard
if Status.is_static(self.data.overview.status):
self.scrolling_finished = True
# If the status is irregular and there's no 'reason' text, finish scrolling
if Status.is_irregular(self.data.overview.status) and Scoreboard(
self.data.overview).get_text_for_reason() is None:
self.scrolling_finished = True
time.sleep(refresh_rate)
endtime = time.time()
time_delta = endtime - self.starttime
rotate_rate = self.__rotate_rate_for_status(
self.data.overview.status)
# If we're ready to rotate, let's do it
if time_delta >= rotate_rate and self.scrolling_finished:
self.starttime = time.time()
self.scrolling_finished = False
self.scrolling_period = 0.0
self.data.needs_refresh = True
if Status.is_fresh(self.data.overview.status):
self.scrolling_text_pos = self.canvas.width
if self.__should_rotate_to_next_game(self.data.overview):
self.scrolling_text_pos = self.canvas.width
game = self.data.advance_to_next_game()
if endtime - self.data.games_refresh_time >= GAMES_REFRESH_RATE:
self.data.refresh_games()
if self.data.needs_refresh:
self.data.refresh_overview()
if Status.is_complete(self.data.overview.status):
if Final(self.data.current_game()
).winning_pitcher == 'Unknown':
self.data.refresh_games()
def render(self):
self.canvas.Fill(*ledcolors.scoreboard.fill)
starttime = time.time()
# Main and only loop
while True:
# If we need to refresh the overview data, do that
if self.data.needs_refresh:
self.data.refresh_overview()
# Draw the current game
self.__draw_game(self.data.current_game(), self.data.overview)
# Check if we need to scroll until it's finished
if self.data.config.scroll_until_finished == False:
self.scrolling_finished = True
# Set the refresh rate
refresh_rate = SCROLL_TEXT_FAST_RATE
if self.data.config.slower_scrolling == True:
refresh_rate = SCROLL_TEXT_SLOW_RATE
# If we're not scrolling anything, scroll is always finished.
if Status.is_static(self.data.overview.status):
self.scrolling_finished = True
time.sleep(refresh_rate)
endtime = time.time()
time_delta = endtime - starttime
rotate_rate = self.__rotate_rate_for_status(
self.data.overview.status)
# If we're ready to rotate, let's do it
if time_delta >= rotate_rate and self.scrolling_finished:
starttime = time.time()
self.scrolling_finished = False
self.data.needs_refresh = True
if Status.is_fresh(self.data.overview.status):
self.scrolling_text_pos = self.canvas.width
if self.__should_rotate_to_next_game(self.data.overview):
self.scrolling_text_pos = self.canvas.width
game = self.data.advance_to_next_game()
self.data.refresh_overview()
if endtime - self.data.games_refresh_time >= GAMES_REFRESH_RATE:
self.data.refresh_games()
def __should_rotate_to_next_game(self, overview):
if self.data.config.rotation_enabled == False:
return False
stay_on_preferred_team = self.data.config.preferred_teams and not self.data.config.rotation_preferred_team_live_enabled
if stay_on_preferred_team == False:
return True
showing_preferred_team = self.data.config.preferred_teams[0] in [overview.away_team_name, overview.home_team_name]
if showing_preferred_team and Status.is_live(overview.status):
if self.data.config.rotation_preferred_team_live_mid_inning == True and Status.is_inning_break(overview.inning_state):
return True
return False
return True
def __should_rotate_to_next_game(self, overview):
if self.data.config.rotation_enabled == False:
return False
stay_on_preferred_team = self.data.config.preferred_teams and not self.data.config.rotation_preferred_team_live_enabled
if stay_on_preferred_team == False:
return True
showing_preferred_team = self.data.config.preferred_teams[0] in [overview.away_team_name, overview.home_team_name]
if showing_preferred_team and Status.is_live(overview.status):
if self.data.config.rotation_preferred_team_live_mid_inning == True and Status.is_inning_break(overview.inning_state):
return True
return False
return True
def __render_game(self):
while True:
# If we need to refresh the overview data, do that
if self.data.needs_refresh:
self.data.refresh_overview()
# Draw the current game
self.__draw_game(self.data.current_game(), self.data.overview)
# Check if we need to scroll until it's finished
if self.data.config.rotation_scroll_until_finished == False:
self.scrolling_finished = True
# Set the refresh rate
refresh_rate = self.data.config.scrolling_speed
# If we're not scrolling anything, scroll is always finished.
if Status.is_static(self.data.overview.status) and not Scoreboard(self.data.overview).get_text_for_reason():
self.scrolling_finished = True
time.sleep(refresh_rate)
endtime = time.time()
time_delta = endtime - self.starttime
rotate_rate = self.__rotate_rate_for_status(self.data.overview.status)
# If we're ready to rotate, let's do it
if time_delta >= rotate_rate and self.scrolling_finished:
self.starttime = time.time()
self.scrolling_finished = False
self.data.needs_refresh = True
if Status.is_fresh(self.data.overview.status):
self.scrolling_text_pos = self.canvas.width
if self.__should_rotate_to_next_game(self.data.overview):
self.scrolling_text_pos = self.canvas.width
game = self.data.advance_to_next_game()
if endtime - self.data.games_refresh_time >= GAMES_REFRESH_RATE:
self.data.refresh_games()
if self.data.needs_refresh:
self.data.refresh_overview()
if Status.is_complete(self.data.overview.status):
if Final(self.data.current_game()).winning_pitcher == 'Unknown':
self.data.refresh_games()
def __should_rotate_to_next_game(self, overview):
if self.data.config.rotate_games == False:
return False
stay_on_preferred_team = self.data.config.preferred_team and self.data.config.stay_on_live_preferred_team
if stay_on_preferred_team == False:
return True
showing_preferred_team = self.data.config.preferred_team in [overview.away_team_name, overview.home_team_name]
if showing_preferred_team and Status.is_live(overview.status):
return False
return True
def get_status(self):
attempts_remaining = 5
while attempts_remaining > 0:
try:
self.status = Status()
break
except ValueError as error_message:
self.network_issues = True
debug.error("Failed to refresh the Status data. {} attempt remaining.".format(attempts_remaining))
debug.error(error_message)
attempts_remaining -= 1
self.status = []
sleep(NETWORK_RETRY_SLEEP_TIME)
