pyws_clock/pyws_clock/clock.py

import datetime

import dateutil
import dateutil.tz

from .errors import AlarmNameError
from .session import Session
from .clock_alarm import ClockAlarm


class Clock(object):
    """ Represents a timezone aware clock with programmable alarms """

    def __init__(self, session_id=None, tzname:str='UTC'):
        """ Instanciate a new clock
            @param tzname : the name of the timezone (UTC for UTC)
        """
        self.__session = Session.get(session_id)
        if 'tzname' in self.__session:
            tzname = self.__session['tzname']
        else:
            self.__session['tzname'] = tzname

        self.__tzname = tzname
        self.__tz = None
        if 'alarms' not in self.__session:
            self.__session['alarms'] = dict()
        self.alarms = self.__session['alarms'] # updated by reference

        self.set_tz(self.__tzname)

    @property
    def tz(self) -> datetime.tzinfo:
        """ Returns the clock tzinfo """
        return self.__tz

    @property
    def tzname(self) -> str:
        """ Returns the clock timezone name """
        tzn1 = datetime.datetime.now(tz=self.__tz).tzname()
        tzn2 = self.__tzname
        return tzn1 if tzn1 == tzn2 else '%s(%s)' % (tzn2, tzn1)

    @property
    def utcoffset(self) -> int:
        """ Returns utcoffset in seconds """
        return datetime.datetime.now(tz=self.__tz).utcoffset()

    @property
    def session_id(self) -> str:
        """ Returns the sesison id """
        return self.__session.session_id

    def now(self) -> datetime.datetime:
        """ Return the clock localtime """
        self.__session.tick()
        now_dt = datetime.datetime.now(tz=self.__tz).replace(microsecond=0)
        for alrm in self.alarms.values():
            alrm.is_ringing()
        return now_dt

    def set_tz(self, tzname:str) -> bool:
        """ Set the clock timezone from dateutil.tz.gettz
            @param tzname : the name of the timezone (UTC for UTC)
            @return True if timezone found else False
        """
        newtz = dateutil.tz.gettz(tzname)
        if newtz is None:
            return False
        self.__tzname = tzname
        self.__tz = dateutil.tz.gettz(tzname)
        self.__session['tzname'] = self.__tzname
        return True

    def alarm_add(self, name:str) -> None:
        """ Add an alarm to the clock
            @param name : alarm name,must be unique
            @throws AlarmNameError if name is not unique or empty
        """
        if name in self.alarms:
            raise AlarmNameError('There is allready an alarm %r' % name)
        self.alarms[name] = ClockAlarm()

    def alarm_del(self, name:str) -> None:
        """ Delete an alarm from the clock
            @param name : the alarm name
            @throws AlarmNameError if alarm not found
        """
        if name not in self.alarms:
            raise AlarmNameError('There is no alarm %r' % name)
        del self.alarms[name]

    def alarm_get(self, name:str) -> None:
        """ Return an alarm given its name
            @param name : the alarm name
            @throws AlarmNameError if alarm not found
        """
        if name not in self.alarms:
            raise AlarmNameError('There is no alarm %r' % name)
        return self.alarms[name]

    def alarm_rings(self) -> list:
        """ Return ringing alarm's names
            @return a list of strings
        """
        return [name for name, alrm in self.alarms.items()
                if alrm.is_ringing()]

    def alarm_snooze(self, minutes:float=15) -> None:
        """ Snooze all ringing alarms
            @param minutes : snooze for this amount of minutes
        """
        for name in self.alarm_rings():
            self.alarms[name].snooze(minutes)