python类begin()的实例源码

def parseEvent(ev, description = True):
    if description:
        name = ev.getEventName()
        description = ev.getShortDescription()
        if description == "":
            description = ev.getExtendedDescription()
    else:
        name = ""
        description = ""
    begin = ev.getBeginTime()
    end = begin + ev.getDuration()
    eit = ev.getEventId()
    begin -= config.recording.margin_before.value * 60
    end += config.recording.margin_after.value * 60
    return (begin, end, name, description, eit)

def __repr__(self):
        return "RecordTimerEntry(name=%s, begin=%s, serviceref=%s, justplay=%s, isAutoTimer=%s)" % (self.name, ctime(self.begin), self.service_ref, self.justplay, self.isAutoTimer)

def calculateFilename(self, name=None):
        service_name = self.service_ref.getServiceName()
        begin_date = strftime("%Y%m%d %H%M", localtime(self.begin))
        name = name or self.name
        filename = begin_date + " - " + service_name
        if name:
            if config.recording.filename_composition.value == "short":
                filename = strftime("%Y%m%d", localtime(self.begin)) + " - " + name
            elif config.recording.filename_composition.value == "long":
                filename += " - " + name + " - " + self.description
            else:
                filename += " - " + name # standard

        if config.recording.ascii_filenames.value:
            filename = ASCIItranslit.legacyEncode(filename)
        if not self.dirname:
            dirname = findSafeRecordPath(defaultMoviePath())
        else:
            dirname = findSafeRecordPath(self.dirname)
            if dirname is None:
                dirname = findSafeRecordPath(defaultMoviePath())
                self.dirnameHadToFallback = True
        if not dirname:
            return None
        self.Filename = Directories.getRecordingFilename(filename, dirname)
        self.log(0, "Filename calculated as: '%s'" % self.Filename)
        return self.Filename

def timeChanged(self):
        old_prepare = self.start_prepare
        self.start_prepare = self.begin - self.prepare_time
        self.backoff = 0

        if int(old_prepare) != int(self.start_prepare):
            self.log(15, "record time changed, start prepare is now: %s" % ctime(self.start_prepare))

def checkWrongRunningTimers(self):
        now = time() + 100
        if int(now) > 1072224000:
            wrong_timers = [entry for entry in (self.processed_timers + self.timer_list) if entry.state in (1, 2) and entry.begin > now]
            for timer in wrong_timers:
                timer.state = RecordTimerEntry.StateWaiting
                self.timeChanged(timer)

def getNextZapTime(self, isWakeup=False):
        now = time()
        for timer in self.timer_list:
            if not timer.justplay or timer.begin < now or isWakeup and timer.zap_wakeup in ("from_standby", "never"):
                continue
            return timer.begin
        return -1

def isNextRecordAfterEventActionAuto(self):
        now = time()
        t = None
        for timer in self.timer_list:
            if timer.justplay or timer.begin < now:
                continue
            if t is None or t.begin == timer.begin:
                t = timer
                if t.afterEvent == AFTEREVENT.AUTO:
                    return True
        return False

def parseEvent(ev):
    begin = ev.getBeginTime()
    end = begin + ev.getDuration()
    return begin, end

def __repr__(self):
        timertype = {
            TIMERTYPE.WAKEUP: "wakeup",
            TIMERTYPE.WAKEUPTOSTANDBY: "wakeuptostandby",
            TIMERTYPE.AUTOSTANDBY: "autostandby",
            TIMERTYPE.AUTODEEPSTANDBY: "autodeepstandby",
            TIMERTYPE.STANDBY: "standby",
            TIMERTYPE.DEEPSTANDBY: "deepstandby",
            TIMERTYPE.REBOOT: "reboot",
            TIMERTYPE.RESTART: "restart"
            }[self.timerType]
        if not self.disabled:
            return "PowerTimerEntry(type=%s, begin=%s)" % (timertype, ctime(self.begin))
        else:
            return "PowerTimerEntry(type=%s, begin=%s Disabled)" % (timertype, ctime(self.begin))

def getNextActivation(self):
        if self.state == self.StateEnded or self.state == self.StateFailed:
            return self.end

        next_state = self.state + 1

        return {self.StatePrepared: self.start_prepare,
                self.StateRunning: self.begin,
                self.StateEnded: self.end }[next_state]

def getNextWakeup(self):
        if self.state == self.StateEnded or self.state == self.StateFailed:
            return self.end

        if self.timerType != TIMERTYPE.WAKEUP and self.timerType != TIMERTYPE.WAKEUPTOSTANDBY and not self.afterEvent:
            return -1
        elif self.timerType != TIMERTYPE.WAKEUP and self.timerType != TIMERTYPE.WAKEUPTOSTANDBY and self.afterEvent:
            return self.end
        next_state = self.state + 1
        return {self.StatePrepared: self.start_prepare,
                self.StateRunning: self.begin,
                self.StateEnded: self.end }[next_state]

def timeChanged(self):
        old_prepare = self.start_prepare
        self.start_prepare = self.begin - self.prepare_time
        self.backoff = 0

        if int(old_prepare) > 60 and int(old_prepare) != int(self.start_prepare):
            self.log(15, "time changed, start prepare is now: %s" % ctime(self.start_prepare))

def createTimer(xml):
    timertype = str(xml.get("timertype") or "wakeup")
    timertype = {
        "wakeup": TIMERTYPE.WAKEUP,
        "wakeuptostandby": TIMERTYPE.WAKEUPTOSTANDBY,
        "autostandby": TIMERTYPE.AUTOSTANDBY,
        "autodeepstandby": TIMERTYPE.AUTODEEPSTANDBY,
        "standby": TIMERTYPE.STANDBY,
        "deepstandby": TIMERTYPE.DEEPSTANDBY,
        "reboot": TIMERTYPE.REBOOT,
        "restart": TIMERTYPE.RESTART
        }[timertype]
    begin = int(xml.get("begin"))
    end = int(xml.get("end"))
    repeated = xml.get("repeated").encode("utf-8")
    disabled = long(xml.get("disabled") or "0")
    afterevent = str(xml.get("afterevent") or "nothing")
    afterevent = {
        "nothing": AFTEREVENT.NONE,
        "wakeuptostandby": AFTEREVENT.WAKEUPTOSTANDBY,
        "standby": AFTEREVENT.STANDBY,
        "deepstandby": AFTEREVENT.DEEPSTANDBY
        }[afterevent]
    autosleepinstandbyonly = str(xml.get("autosleepinstandbyonly") or "no")
    autosleepdelay = str(xml.get("autosleepdelay") or "0")
    autosleeprepeat = str(xml.get("autosleeprepeat") or "once")

    entry = PowerTimerEntry(begin, end, disabled, afterevent, timertype)
    entry.repeated = int(repeated)
    entry.autosleepinstandbyonly = autosleepinstandbyonly
    entry.autosleepdelay = int(autosleepdelay)
    entry.autosleeprepeat = autosleeprepeat

    for l in xml.findall("log"):
        time = int(l.get("time"))
        code = int(l.get("code"))
        msg = l.text.strip().encode("utf-8")
        entry.log_entries.append((time, code, msg))

    return entry

def doActivate(self, w):
        # when activating a timer which has already passed,
        # simply abort the timer. don't run trough all the stages.
        if w.shouldSkip():
            w.state = PowerTimerEntry.StateEnded
        else:
            # when active returns true, this means "accepted".
            # otherwise, the current state is kept.
            # the timer entry itself will fix up the delay then.
            if w.activate():
                w.state += 1

        try:
            self.timer_list.remove(w)
        except:
            print '[PowerManager]: Remove list failed'

        # did this timer reached the last state?
        if w.state < PowerTimerEntry.StateEnded:
            # no, sort it into active list
            insort(self.timer_list, w)
        else:
            # yes. Process repeated, and re-add.
            if w.repeated:
                # If we have saved original begin/end times for a backed off timer
                # restore those values now
                if hasattr(w, "real_begin"):
                    w.begin = w.real_begin
                    w.end = w.real_end
                    # Now remove the temporary holding attributes...
                    del w.real_begin
                    del w.real_end
                w.processRepeated()
                w.state = PowerTimerEntry.StateWaiting
                self.addTimerEntry(w)
            else:
                # Remove old timers as set in config
                self.cleanupDaily(config.recording.keep_timers.value)
                insort(self.processed_timers, w)
        self.stateChanged(w)

def parseEvent(ev, description = True):
    if description:
        name = ev.getEventName()
        description = ev.getShortDescription()
        if description == "":
            description = ev.getExtendedDescription()
    else:
        name = ""
        description = ""
    begin = ev.getBeginTime()
    end = begin + ev.getDuration()
    eit = ev.getEventId()
    begin -= config.recording.margin_before.value * 60
    end += config.recording.margin_after.value * 60
    return (begin, end, name, description, eit)

def __repr__(self):
        if not self.disabled:
            return "RecordTimerEntry(name=%s, begin=%s, serviceref=%s, justplay=%s, isAutoTimer=%s)" % (self.name, ctime(self.begin), self.service_ref, self.justplay, self.isAutoTimer)
        else:
            return "RecordTimerEntry(name=%s, begin=%s, serviceref=%s, justplay=%s, isAutoTimer=%s, Disabled)" % (self.name, ctime(self.begin), self.service_ref, self.justplay, self.isAutoTimer)

def timeChanged(self):
        old_prepare = self.start_prepare
        self.start_prepare = self.begin - self.prepare_time
        self.backoff = 0

        if int(old_prepare) > 60 and int(old_prepare) != int(self.start_prepare):
            self.log(15, "record time changed, start prepare is now: %s" % ctime(self.start_prepare))

def checkWrongRunningTimers(self):
        now = time() + 100
        if int(now) > 1072224000:
            wrong_timers = [entry for entry in (self.processed_timers + self.timer_list) if entry.state in (1, 2) and entry.begin > now]
            for timer in wrong_timers:
                timer.state = RecordTimerEntry.StateWaiting
                self.timeChanged(timer)

def getNextZapTime(self):
        now = time()
        for timer in self.timer_list:
            if not timer.justplay or timer.begin < now:
                continue
            return timer.begin
        return -1

def getStillRecording(self):
        isStillRecording = False
        now = time()
        for timer in self.timer_list:
            if timer.isStillRecording:
                isStillRecording = True
                break
            elif abs(timer.begin - now) <= 10:
                isStillRecording = True
                break
        return isStillRecording