raceclock.py

#!/usr/bin/env python3

"""Race Clock Classes

This module implements the digital clock used to display current race time.
Upon instantiation, we also validate that the current system time is in sync
with Internet (cellphone) time.
"""

import ntplib
from PyQt5.QtCore import QDate, QDateTime, QTime, QTimer
from PyQt5.QtWidgets import QFrame, QLCDNumber, QMessageBox
import common
from defaults import NTP_SERVER_NUM_CHECKS

__copyright__ = '''
    Copyright (C) 2018-2019 Andrew Chew

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
'''
__author__ = common.AUTHOR
__credits__ = common.CREDITS
__license__ = common.LICENSE
__version__ = common.VERSION
__maintainer__ = common.MAINTAINER
__email__ = common.EMAIL
__status__ = common.STATUS

# Use NTP pool for our time server.
NTP_SERVER = 'pool.ntp.org'

# NCNCA race officials seem to like reporting two significant digits of fractional seconds.
ACCEPTABLE_OFFSET = 0.01

class RaceClockException(BaseException):
    """Exceptions generated by this module."""

class DigitalClock(QLCDNumber):
    """Old-fashioned 7-segment display digital clock showing current time."""
    def __init__(self, modeldb, validate_clock=True, parent=None):
        """Initialize the DigitalClock instance."""
        super().__init__(8, parent=parent)

        self.modeldb = modeldb
        self.preferences = None

        self.setFrameShape(QFrame.NoFrame)
        self.setSegmentStyle(QLCDNumber.Filled)

        self.timer = QTimer()
        self.timer.timeout.connect(self.update)
        self.update()
        self.timer.start(100)

        self.setMinimumHeight(48)

        if validate_clock:
            self.validate_clock()

    def update(self):
        """Update text on the LCD display."""
        race_table_model = self.modeldb.race_table_model

        if self.preferences and self.preferences.wall_times_checkbox.isChecked():
            msecs = race_table_model.get_wall_time_msecs()
        else:
            msecs = race_table_model.get_reference_msecs()
        datetime = QDateTime(QDate(1, 1, 1), QTime(0, 0)).addMSecs(msecs)

        if datetime.time().second() % 2:
            datetime_string = 'h:mm ss'
        else:
            datetime_string = 'h:mm:ss'

        if (self.preferences and
            self.preferences.wall_times_checkbox.isChecked() and
            not self.preferences.h24_wall_times_checkbox.isChecked()):
            self.setDigitCount(11)
            datetime_string += ' a'
        else:
            self.setDigitCount(8)

        text = datetime.toString(datetime_string)

        self.display(text)

    def validate_clock(self):
        """Check against an NTP server to see if our system time is in sync.

        San Bruno Hill Climb 2019's mysterious ~40s offset issue. Never forget!
        """
        err_text = None

        ntp_client = ntplib.NTPClient()

        # Try NTP server clock check some number of times, and take the average.
        total = 0.0
        num = 0
        for _ in range(NTP_SERVER_NUM_CHECKS):
            try:
                response = ntp_client.request(NTP_SERVER)
                total += response.offset
                num += 1
            except Exception as e: #pylint: disable=broad-except
                reason = str(e)

        if num == 0:
            err_text = ('Failed to validate clock against NTP server ' + NTP_SERVER + '.\n\n' +
                        'Reason: %s' % reason)
        else:
            average = total / num
            if average > ACCEPTABLE_OFFSET:
                err_text = ('System time seems to be off by %.2f seconds! ' % average +
                            'Results were averaged across %s checks.' % num +
                            'Please check system settings to ensure that the clock is being ' +
                            'synchronized with an internet time server.')

        if not err_text:
            return

        if QMessageBox.warning(self, 'Warning', err_text,
                               QMessageBox.Abort | QMessageBox.Ignore,
                               QMessageBox.Abort) == QMessageBox.Abort:
            raise RaceClockException('Aborting due to system time validation failure.')

        message = ("Recorded times will not be consistent with officials' times if Internet " +
                   "(cellphone) time is used.\n\nYOU HAVE BEEN WARNED!")

        QMessageBox.warning(self, 'Warning', message)

    def connect_preferences(self, preferences):
        """Connect preferences signals to the various slots that care."""
        self.preferences = preferences

        preferences.digital_clock_checkbox.stateChanged.connect(self.setVisible)
        self.setVisible(preferences.digital_clock_checkbox.checkState())
        preferences.wall_times_checkbox.stateChanged.connect(self.update)
        preferences.h24_wall_times_checkbox.stateChanged.connect(self.update)