myscheduler.py

#!/usr/bin/python3

import datetime
import locale
import re
import sys
import threading
import time
import traceback

import ephem

try:
    from mylog import MyLog
except Exception as e1:
    print("\n\nThis program requires the modules located from the same github repository that are not present.\n")
    print("Error: " + str(e1))
    sys.exit(2)


class Event:
    ## active: Either 'active', 'paused', 'deleted'
    ## repeatType: String: 'once' or 'weekday'
    ## repeatValue: Date in format "YYYY/MM/DD" or Array ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
    ## timeType: String: 'clock' or 'astro' are valid values
    ## timeValue: String: Time in format "HH:MM" or values 'sunset' or 'sunrise' or 'sunset+MIN', 'sunset-MIN', 'sunrise+MIN', 'sunrise-MIN'
    ## shutterAction: String: 'up', 'down' or 'stop' (My-Position) are valid values. If this is followed by an integer, this indicates the duration of the operation
    ## shutterIds: Array of shutterIds to operate

    def __init__(self,active,repeatType,repeatValue,timeType,timeValue,shutterAction,shutterIds):
    
        if active not in ('active', 'paused', 'deleted'):
            raise ValueError("%s is not a valid value for ACTIVE." % active )
        self.active = active

        if repeatType not in ('once', 'weekday'):
            raise ValueError("%s is not a valid value for REPEATTYPE." % timeType)
        self.repeatType = repeatType
                
        if (repeatValue == 'weekday') and not all(elem in ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'] for elem in repeatValue):
            raise ValueError("%s is not a valid value for REPEATVALUE (weekday)." % repeatValue )
        if (repeatValue == 'once') and not (datetime.datetime.strptime(repeatValue, '%Y/%m/%d')):
            raise ValueError("%s is not a valid value for REPEATVALUE (once)." % repeatValue )
        self.repeatValue = repeatValue
        
        if timeType not in ('clock', 'astro'):
            raise ValueError("%s is not a valid value for TIMETYPE." % timeType)
        self.timeType = timeType

        if (timeType == "clock") and not time.strptime(timeValue, '%H:%M'):
            raise ValueError("%s is not a valid value for TIMEVALUE (clock)." % timeValue )
        astro_parts = re.split('\+|\-', timeValue)
        if (timeType == "astro") and not ((astro_parts[0] in ('sunset', 'sunrise')) and ((len(astro_parts) == 1) or (astro_parts[1] == None or int(astro_parts[1])))):
            raise ValueError("%s is not a valid value for TIMEVALUE (astro)." % timeValue)
        self.timeValue = timeValue

        # if not ((isinstance(shutterAction, str)) and ((shutterAction.startswith("up") or shutterAction.startswith("down")))):
        if not ((shutterAction.startswith("up") or shutterAction.startswith("down") or shutterAction.startswith("stop"))):
            raise ValueError("%s is not a valid value for ACTION." % shutterAction)
        self.shutterAction = shutterAction

        self.shutterIds = shutterIds
        
    def prettyprint(self):
        outstr  = "active        : "+str(self.active)+"\n"
        outstr += "repeatType    : "+str(self.repeatType)+"\n"
        outstr += "repeatValue   : "+str(self.repeatValue)+"\n"
        outstr += "timeType      : "+str(self.timeType)+"\n"
        outstr += "timeValue     : "+str(self.timeValue)+"\n"
        outstr += "shutterAction : "+str(self.shutterAction)+"\n"
        outstr += "shutterIds    : "+str(self.shutterIds)+"\n"
        
        return outstr
           
class Schedule(MyLog):
    def __init__(self, log = None, config = None):
        super(Schedule, self).__init__()
        self.lock = threading.Lock()
        if log != None:
            self.log = log
        self.config = config

        self.schedule = {}
        self.setUpdateTime()
        
    def addEvent(self, id, evt):
        if id in self.schedule.items():
            self.LogError("Event ID is not unique: "+ str(id))
            
        self.LogDebug('addEvent: Waiting for Lock')
        self.lock.acquire()
        try:
            self.LogDebug('addEvent: Lock aquired')
            self.schedule[id] = evt
            self.setUpdateTime()
        finally:
            self.lock.release()
            self.LogDebug('addEvent: Lock released')
            
    def getNewId(self):
        ids = []
        for key in self.schedule:
            ids.append(int(key))
        if len(ids) == 0:
            return 1
        return (max(ids)+1)
            
    def addOneEventByTime(self, shutterIds, shutterAction, hour, minute):
        try: 
            evt = Event('active', 'once', datetime.datetime.today().strftime('%Y/%m/%d'), "clock", str(hour)+":"+str(minute), shutterAction, shutterIds)
            self.addEvent(self.getNewId(), evt)
        except ValueError as ex:
            self.LogError("Failed to add event: "+ str(ex))
            pass

    def addRepeatEventByTime(self, shutterIds, shutterAction, hour, minute, weekdays):
        try: 
            evt = Event('active', 'weekday', weekdays, "clock", str(hour)+":"+str(minute), shutterAction, shutterIds)
            self.addEvent(self.getNewId(), evt)
        except ValueError as ex:
            self.LogError("Failed to add event: "+ str(ex))
            pass

    def addRepeatEventBySunrise(self, shutterIds, shutterAction, delay, weekdays):
        try: 
            timeValue = "sunrise"
            if int(delay) > 0:
               timeValue = "sunrise+"+str(delay)
            if int(delay) < 0:
               timeValue = "sunrise"+str(delay)
            evt = Event('active', 'weekday', weekdays, "astro", timeValue, shutterAction, shutterIds)
            self.addEvent(self.getNewId(), evt)
        except ValueError as ex:
            self.LogError("Failed to add event: "+ str(ex))
            pass

    def addRepeatEventBySunset(self, shutterIds, shutterAction, delay, weekdays):
        try: 
            timeValue = "sunset"
            if int(delay) > 0:
               timeValue = "sunset+"+str(delay)
            if int(delay) < 0:
               timeValue = "sunset"+str(delay)
            evt = Event('active', 'weekday', weekdays, "astro", timeValue, shutterAction, shutterIds)
            self.addEvent(self.getNewId(), evt)
        except ValueError as ex:
            self.LogError("Failed to add event: "+ str(ex))
            pass
            
    def loadScheudleFromConfig(self):
        self.LogDebug("Loading Schedule from Config File")
        for id, data in self.config.Schedule.items():
            self.LogDebug("Loading Scheudle "+str(id))
            if data['repeatType'] == 'weekday':
               repeatValue = data['repeatValue'].split("|")
            else:
               repeatValue = data['repeatValue']
            evt =  Event(data['active'],data['repeatType'],repeatValue,data['timeType'],data['timeValue'],data['shutterAction'],data['shutterIds'].split("|"))
            self.addEvent(id, evt)
            
    def addSchedule(self, data):
        id = self.getNewId()
        
        active = data['active'][0]
        repeatType = data['repeatType'][0]
        repeatValueStr = data['repeatValue'][0] if (data['repeatType'][0] == "once") else "|".join(data['repeatValue[]'])
        repeatValueList = data['repeatValue'][0] if (data['repeatType'][0] == "once") else data['repeatValue[]']
        timeType = data['timeType'][0]
        timeValue = data['timeValue'][0]
        shutterAction = data['shutterAction'][0]
        shutterIdsList = data['shutterIds[]']
        shutterIdsStr = "|".join(shutterIdsList)
           
        self.config.WriteValue(str(id), active+","+repeatType+","+repeatValueStr+","+timeType+","+timeValue+","+shutterAction+","+shutterIdsStr, 
                                   section="Scheduler");
        self.config.Schedule[str(id)] = {'active': active, 'repeatType': repeatType, 'repeatValue': repeatValueStr, 
                                    'timeType': timeType, 'timeValue': timeValue, 'shutterAction': shutterAction, 
                                    'shutterIds': shutterIdsStr}


        evt =  Event(active,repeatType,repeatValueList,timeType,timeValue,shutterAction,shutterIdsList)
        self.addEvent(str(id), evt)
            
        self.setUpdateTime()
        return { 'status': 'OK', 'id': str(id) }

    def editSchedule(self, id, data):
        if ((not id in self.schedule) or (not id in self.config.Schedule)):
            return {'status': 'ERROR', 'message': 'Schedule does not exist'}
        else:
            evt = self.config.Schedule[id]
            active = data['active'][0]
            repeatType = data['repeatType'][0]
            repeatValueStr = data['repeatValue'][0] if (data['repeatType'][0] == "once") else "|".join(data['repeatValue[]'])
            repeatValueList = data['repeatValue'][0] if (data['repeatType'][0] == "once") else data['repeatValue[]']
            timeType = data['timeType'][0]
            timeValue = data['timeValue'][0]
            shutterAction = data['shutterAction'][0]
            shutterIdsList = data['shutterIds[]']
            shutterIdsStr = "|".join(shutterIdsList)
            
            self.config.WriteValue(str(id), active+","+repeatType+","+repeatValueStr+","+timeType+","+timeValue+","+shutterAction+","+shutterIdsStr, 
                                   section="Scheduler");
            self.config.Schedule[id] = {'active': active, 'repeatType': repeatType, 'repeatValue': repeatValueStr, 
                                        'timeType': timeType, 'timeValue': timeValue, 'shutterAction': shutterAction, 
                                        'shutterIds': shutterIdsStr}

            self.schedule.pop(id, None)
            evt =  Event(active,repeatType,repeatValueList,timeType,timeValue,shutterAction,shutterIdsList)
            self.addEvent(id, evt)
            
            self.setUpdateTime()
            return {'status': 'OK'}

    def deleteSchedule(self, id):
        if ((not id in self.schedule) or (not id in self.config.Schedule)):
            return {'status': 'ERROR', 'message': 'Schedule does not exist'}
        else:
            evt = self.config.Schedule[id]
            self.config.WriteValue(str(id), "deleted,"+evt['repeatType']+","+evt['repeatValue']+","+
                                            evt['timeType']+","+evt['timeValue']+","+evt['shutterAction']+","+
                                            evt['shutterIds'], section="Scheduler");
            self.config.Schedule.pop(id, None)
            self.schedule.pop(id, None)
            self.setUpdateTime()
            return {'status': 'OK'}
            
    def printSchedule(self):
        for id, evt in self.schedule.items():
           print ("")
           print ("Event: "+str(id))
           print (evt.prettyprint())

    def getSchedule(self):
        return self.schedule

    def getScheduleAsDict(self):
        obj = {}
        for id, evt in self.schedule.items():
            if evt.active != "deleted":
                item = {'active': evt.active, 'repeatType':evt.repeatType, 'repeatValue':evt.repeatValue, 'timeType':evt.timeType, 'timeValue': evt.timeValue, 'shutterIds': evt.shutterIds, 'shutterAction': evt.shutterAction}
                obj[id] = item
        return obj

    def setUpdateTime(self):
        self.updateTime = int(time.time())

    def getUpdateTime(self):
        return self.updateTime
        

class Scheduler(threading.Thread, MyLog):

    def __init__(self, group=None, target=None, name=None, args=(), kwargs=None):
        threading.Thread.__init__(self, group=group, target=target, name="Scheduler")
        self.shutdown_flag = threading.Event()
        
        self.args = args
        self.kwargs = kwargs
        if kwargs["log"] != None:
            self.log = kwargs["log"]
        self.schedule = kwargs["schedule"]
        self.shutter = kwargs["shutter"]
        self.config = kwargs["config"]
        self.weekday = datetime.datetime.today().weekday()
        self.lastScheduleUpdateTime = 0
        self.currentSchedule = {}

        self.homeLocation = ephem.Observer()
        locale.setlocale(locale.LC_TIME,'')
        return

    def updateSchedule(self):
        weekDays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
        
        self.homeLocation.lat = str(self.config.Latitude)
        self.homeLocation.lon = str(self.config.Longitude)
        self.homeLocation.date = datetime.datetime.now().strftime("%Y/%m/%d 00:00:00")
        sunrise = ephem.localtime(self.homeLocation.next_rising(ephem.Sun()))
        sunset = ephem.localtime(self.homeLocation.next_setting(ephem.Sun()))
        weekday = weekDays[datetime.datetime.today().weekday()]
        date    = datetime.datetime.today().strftime('%Y/%m/%d')
        self.LogInfo("Today is "+date+", a "+weekday+", Sunrise is at "+str(sunrise.time())+" and Sunset is at "+ str(sunset.time()));

        self.currentSchedule = {}
        for id, event in self.schedule.getSchedule().items():
            if ((event.active == "active") and (((event.repeatType == 'weekday') and (weekday in event.repeatValue)) or ((event.repeatType == 'once') and (date == event.repeatValue)))):
                if (event.timeType == "clock"):
                    eventTime = datetime.time(int(event.timeValue.split(":")[0]), int(event.timeValue.split(":")[1]), 0)
                elif ((event.timeType == "astro") and (event.timeValue.startswith("sunrise"))):
                    eventTime = (sunrise + datetime.timedelta(minutes=int(event.timeValue[7:] or 0))).time()
                elif ((event.timeType == "astro") and (event.timeValue.startswith("sunset"))):
                    eventTime = (sunset + datetime.timedelta(minutes=int(event.timeValue[6:] or 0))).time()

                if (eventTime > datetime.datetime.now().time()): 
                    eventTimeStr = "%02d:%02d" % (eventTime.hour, eventTime.minute)
                    if not eventTimeStr in self.currentSchedule:
                        self.currentSchedule[eventTimeStr] = []
                    self.currentSchedule[eventTimeStr].append([event.shutterIds, event.shutterAction])  
        self.LogDebug(str(self.currentSchedule))
    
    def run(self):
        # self.schedule.printSchedule()
        while not self.shutdown_flag.is_set():
            currentScheduleUpdateTime = self.schedule.getUpdateTime();
            if ((self.lastScheduleUpdateTime < currentScheduleUpdateTime) or (self.weekday != datetime.datetime.today().weekday())):
                self.updateSchedule()
                self.weekday = datetime.datetime.today().weekday()
                self.lastScheduleUpdateTime = currentScheduleUpdateTime
               
            ## check next event 
            timeNow = datetime.datetime.now().time()
            timeNowStr = "%02d:%02d" % (timeNow.hour, timeNow.minute)
            eventsToDelete = [];
            for eventTimeStr, eventDetails in self.currentSchedule.items():
                if (eventTimeStr <= timeNowStr):
                    for eventDetail in eventDetails:
                        for shutterId in eventDetail[0]:
                            try:
                                self.LogInfo("Send action \""+eventDetail[1]+"\" to shutterId \""+shutterId+"\" at " + datetime.datetime.now().strftime("%Y/%m/%d %H:%M:%S"))
                                if (eventDetail[1].startswith("up")):
                                    s = eventDetail[1][2:].strip()
                                    s1 = int(s) if s else -1
                                    if (0 < s1 < 100):
                                        if (self.shutter.getPosition(shutterId) < s1):   #Is Shutter below requested Position?
                                            self.shutter.risePartial(shutterId, s1)
                                        else:
                                            self.LogWarn("Send action \""+eventDetail[1]+"\" to shutterId \""+shutterId+"\" was canceled! Shutter was already at same or above requested position")                                      
                                    else :  
                                        for i in range(self.config.SendRepeat):
                                            self.shutter.rise(shutterId)
                                            time.sleep(5)
                                elif (eventDetail[1].startswith("down")):
                                    s = eventDetail[1][4:].strip()
                                    s1 = int(s) if s else -1
                                    if (0 < s1 < 100):
                                        if (self.shutter.getPosition(shutterId) > s1):   #Is Shutter above requested Position?
                                            self.shutter.lowerPartial(shutterId, s1)
                                        else:
                                            self.LogWarn("Send action \""+eventDetail[1]+"\" to shutterId \""+shutterId+"\" was canceled! Shutter was already at same or below requested position")                                         
                                    else :  
                                        for i in range(self.config.SendRepeat):
                                            self.shutter.lower(shutterId)
                                            time.sleep(5)
                                elif (eventDetail[1].startswith("stop")):
                                    self.shutter.stop(shutterId)
                            except:
              	                self.LogError ("Error: cannot open "+shutterId)
              	                self.LogError (traceback.format_exc())
                    eventsToDelete.append(eventTimeStr);    
            for key in eventsToDelete:
                try:
                    del self.currentSchedule[key] 
                except KeyError:
                    pass
            if (len(eventsToDelete) > 0):
                self.LogDebug(str(self.currentSchedule))
         
            self.shutdown_flag.wait(60 - datetime.datetime.now().time().second)
            
        self.LogError("Received Signal to shut down Scheduler thread")
        return