Exemple #1
0
    def cacheFrames(self, stream, start=False):
        if stream.caching is None:
            stream.caching = [stream.seek_index, start, getTime()]
        while stream.caching is not None:
            if stream.caching[0] < stream.stream.index:
                if stream.caching[0] == stream.seek_index:
                    self.writeMessage(
                        stream.stream.getDescription(Stream.FRAME_TYPE_VIDEO,
                                                     stream.caching[1]))
                self.writeMessage(
                    stream.stream.getVideoFrame(stream.caching[0],
                                                stream.seek_time))
                stream.caching[0] += 1
            else:
                stream.start_time += getTime() - stream.caching[2]
                stream.caching = None
                self.writeMessage(stream.stream.getSeekFrame())

                if stream.paused is not None:
                    stream.seek_pause = True
                    self.writeMessage(stream.stream.getPauseFrame())
                    self.writeMessage(
                        stream.stream.getDescription(Stream.FRAME_TYPE_AUDIO))
                    self.sendBlankAudioFrame(stream)
                    self.sendClearPlay(stream.id)
                else:
                    self.writeMessage(
                        stream.stream.getDescription(Stream.FRAME_TYPE_AUDIO))
                    #self.paused = getTime()
            if self.blocking():
                break
Exemple #2
0
def iterateAttackers(iterable, avgCount, gameTypeList, overBudgets):
    utilities = [0] * len(gameTypeList)
    times = [0] * len(gameTypeList)
    for _ in range(avgCount):
        print(f"set {_} of {avgCount} for {iterable}")
        # Generate a new game
        defenders, dRewards, dPenalties, dCosts = generateRandomDefenders(
            DEFENDERNUM, TARGETNUM)
        aTypes, aRewards, aPenalties, q = generateRandomAttackers(
            iterable, TARGETNUM)

        gameIndex = 0
        for gameType, overBudget in zip(gameTypeList, overBudgets):
            if not overBudgets[gameIndex]:
                start = getTime()
                utilities[gameIndex] += gameType(TARGETNUM, defenders,
                                                 dRewards, dPenalties, dCosts,
                                                 aTypes, aRewards, aPenalties,
                                                 q)[GAMEUTILITY]
                times[gameIndex] += getTime() - start
            else:
                utilities[gameIndex] = None
                times[gameIndex] = None
            gameIndex += 1
    for gameIndex in range(len(gameTypeList)):
        if not overBudgets[gameIndex]:
            utilities[gameIndex] /= avgCount
            times[gameIndex] /= avgCount

    return utilities, times
def CallF16Sim_cpp(parameters="", MeasureTime=False):  #True):

    if os.name == "nt":
        #cmd = 'bash -c "'+cmd+'"'
        cmd = "../F16Sim.exe"
    else:
        cmd = "./../F16Sim"

    cmd += " " + parameters
    if MeasureTime: t0_ = getTime()

    if 0:
        os.system(cmd)
    elif 1:
        subprocess.call(shlex.split(cmd))
        #subprocess.call(cmd,shell=True)
    else:
        p = subprocess.Popen(shlex.split(cmd))
        p.wait()

    if MeasureTime:
        dt_ = getTime() - t0_
        print "Sim exe time: " + str(round(dt_ * 1000,
                                           2)) + " ms | MaxFreq: " + str(
                                               round(1. / dt_, 2)) + " Hz"
Exemple #4
0
    def cacheFrames(self, stream, start=False):
        if stream.caching is None:
            stream.caching = [stream.seek_index, start, getTime()]
        while stream.caching is not None:
            if stream.caching[0] < stream.stream.index:
                if stream.caching[0] == stream.seek_index:
                    self.writeMessage(stream.stream.getDescription(Stream.FRAME_TYPE_VIDEO, stream.caching[1]))
                self.writeMessage(stream.stream.getVideoFrame(stream.caching[0], stream.seek_time))
                stream.caching[0] += 1
            else:
                stream.start_time += getTime() - stream.caching[2]
                stream.caching = None
                self.writeMessage(stream.stream.getSeekFrame())

                if stream.paused is not None:
                    stream.seek_pause = True
                    self.writeMessage(stream.stream.getPauseFrame())
                    self.writeMessage(stream.stream.getDescription(Stream.FRAME_TYPE_AUDIO))
                    self.sendBlankAudioFrame(stream)
                    self.sendClearPlay(stream.id)
                else:
                    self.writeMessage(stream.stream.getDescription(Stream.FRAME_TYPE_AUDIO))
                    # self.paused = getTime()
            if self.blocking():
                break
def menuInteractiveQuery(eng, rankingSize):
    eng = loadIndexWrapper(eng)

    qId = 1
    while True:
        try:
            queryString = raw_input(">> ")
        except EOFError:
            print('')
            break
        except KeyboardInterrupt:
            print('')
            break
        query = Query(qId, queryString, [])

        start = getTime()
        results, evalResults = eng.processQuery(query, rankingSize)
        print("It took {} s to process the query."
                .format(getTime() - start))

        for result in results:
            similarity, doc = result
            print("similarity: {}. id: {}"
                    .format(similarity, doc.id))
            print("\ttitle: {}".format(doc.title))
            print("\tauthors: {}, year: {}\n"
                    .format(doc.authors, doc.year))
Exemple #6
0
def main():
    # Get the arguments
    args = sys.argv[1:]
    # check if we start from the beginning or not
    gameNum = 0
    avgTime = 0
    avgUtilityPerDefender = 0
    avgUtilityPerAttacker = 0
    if len(args) == 4:
        methodName, tNum, aNum, dNum = args
    else:
        methodName, tNum, aNum, dNum, startIndex, avgTime, avgUtilityPerDefender, avgUtilityPerAttacker = args
        avgTime, avgUtilityPerDefender, avgUtilityPerAttacker = [
            float(arg)
            for arg in [avgTime, avgUtilityPerDefender, avgUtilityPerAttacker]
        ]
        gameNum = int(startIndex)
    tNum, aNum, dNum = [int(arg) for arg in [tNum, aNum, dNum]]
    method = methodDict[methodName]

    # Games location:
    fileName = getFileName(tNum, aNum, dNum)

    # Read in the games
    numGames, games = readGames(fileName)

    print(numGames)

    # Run the games and time them
    while gameNum < numGames:
        print(f"Running game {gameNum} for method {methodName}")
        game = games[gameNum]
        defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q = game
        start = getTime()
        utilityPerDefender, utilityPerAttacker, extras = method(
            tNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards,
            aPenalties, q)
        time = getTime() - start
        avgTime += time
        avgUtilityPerDefender += utilityPerDefender
        avgUtilityPerAttacker += utilityPerAttacker
        print(
            f"current sums (not divided yet): time: {avgTime}, defUtil: {avgUtilityPerDefender}, attUtil: {avgUtilityPerAttacker}"
        )
        gameNum += 1
    avgTime /= numGames
    avgUtilityPerDefender /= numGames
    avgUtilityPerAttacker /= numGames
    print(
        f"Average time for method {methodName} with {tNum} targets, {aNum} attackers, and {dNum} defenders: {avgTime}"
    )
    print(
        f"Average utility per defender for method {methodName} with {tNum} targets, {aNum} attackers, and {dNum} defenders: {avgUtilityPerDefender}"
    )
    print(
        f"Average utility per attacker for method {methodName} with {tNum} targets, {aNum} attackers, and {dNum} defenders: {avgUtilityPerAttacker}"
    )
Exemple #7
0
def loadIndexWrapper(eng):
    try:
        start = getTime()
        eng.loadIndex(INDEX_PATH)
        print("It took {:.5f} s to load the index.".format(getTime() - start))
    except IOError:
        print("Could not read the index at path: {}".format(INDEX_PATH))
        print("Please create the index first with argument '{}'.".format(
            CREATE_INDEX_CMD))
        sys.exit(-1)
    return eng
def loadIndexWrapper(eng):
    try:
        start = getTime()
        eng.loadIndex(INDEX_PATH)
        print("It took {:.5f} s to load the index."
                .format(getTime() - start))
    except IOError:
        print("Could not read the index at path: {}".format(INDEX_PATH))
        print("Please create the index first with argument '{}'."
                .format(CREATE_INDEX_CMD))
        sys.exit(-1)
    return eng
    def TrackTime(self):
        self.dt = getTime() - self.t
        self.t = getTime()

        if self.dt != 0:
            self.freq = 1. / self.dt
        else:
            self.freq = 0

        self.DT = self.t - self.t0

        self.ShowTimeText()
Exemple #10
0
def menuQueryFile(eng, queryFile, rankingSize):
    eng = loadIndexWrapper(eng)

    if not queryFile:
        print(
            "Please enter the path to the cfc query file using the -in argument"
        )
        sys.exit(-1)

    print("ranking size: {}".format(rankingSize))

    MAPs = []
    recallPointsLst = []
    pAtTens = []
    times = []
    try:
        print("query id ; P@10 ; interpolated MAP ; time (s)")
        for query in eng.parser.parseQueryFile(queryFile):
            start = getTime()
            results, evalResults = eng.processQuery(query,
                                                    rankingSize,
                                                    evaluate=True)
            end = getTime() - start

            MAPs.append(evalResults["MAP"])
            recallPointsLst.append(evalResults["recallPoints"])
            pAtTens.append(evalResults["P@10"])
            times.append(end)
            print("{:03d} ; {:.5f} ; {:.5f} ; {:.5f} ".format(
                query.id, pAtTens[-1], MAPs[-1], times[-1]))
    except IOError as e:
        print("Could not open the cfc query file at: {}.".format(queryFile))
        print(e.message)
        sys.exit(-1)

    avgRecallPoints = Evaluator.getAverageRecallPoints(recallPointsLst)
    avgMAP = sum(MAPs) / len(MAPs)
    avgPAtTen = sum(pAtTens) / len(pAtTens)
    avgTime = sum(times) / len(times)
    print("\nAverages:")

    print("\tP@10: {:.5f}".format(avgPAtTen))
    print("\tinterpolated MAP: {:.5f}".format(avgMAP))
    print("\ttime: {:.5f} s".format(avgTime))

    print("\tinterpolated recall points (precision, recall):")
    for pair in avgRecallPoints:
        p, r = pair
        print("\t({:.5f}, {:.5f}),".format(p, r))
Exemple #11
0
    def commandPause(self, info, _, pause=False, time=None):
        stream = self.getStream(info[1][4])
        if stream is None: return

        if pause == True:
            stream.paused = getTime()
        elif stream.paused is not None:
            if stream.seek_pause:
                stream.seek_pause = False
                stream.paused = None
                self.seek(stream, (stream.seek_time, time)[time is not None],
                          BROADCAST_UNPAUSE)
            else:
                stream.start_time += getTime() - stream.paused
                stream.paused = None
Exemple #12
0
    def commandPause(self, info, _, pause=False, time=None):
        stream = self.getStream(info[1][4])
        if stream is None:
            return

        if pause == True:
            stream.paused = getTime()
        elif stream.paused is not None:
            if stream.seek_pause:
                stream.seek_pause = False
                stream.paused = None
                self.seek(stream, (stream.seek_time, time)[time is not None], BROADCAST_UNPAUSE)
            else:
                stream.start_time += getTime() - stream.paused
                stream.paused = None
Exemple #13
0
    def startBroadcast(self, stream, type):
        stream.stopped = False
        stream.start_time = getTime() - self.BUFFER_TIME_S - (float(stream.seek_time) / 1000.0)
        seek_time = stream.seek_time - (0, stream.cur_time)[stream.cur_time < stream.seek_time]
        stream.cur_time = stream.stream.base_time
        stream.sleep = 0.0

        start = type == BROADCAST_START
        stream_id = (None, stream.id)[start]

        self.rtmp.setChunkSize(4096)
        self.sendChunkSize(self.rtmp.getChunkSize())

        if type == BROADCAST_SEEK:
            self.sendClearPlay(stream.id)

        self.sendReset(stream.id)
        self.sendClear(stream.id)

        if type == BROADCAST_START:
            self.sendNetStreamPlayReset(stream, 0, stream_id)
        elif type == BROADCAST_SEEK:
            self.sendNetStreamSeekNotify(stream, seek_time, (stream_id, stream.id)[seek_time == stream.seek_time])
        elif type == BROADCAST_UNPAUSE:
            self.sendNetStreamUnpauseNotify(stream, 0, stream_id)

        self.sendNetStreamPlayStart(stream, 0, stream_id)

        self.sendRtmpSampleAccess(stream, stream_id)
        self.sendBlankAudioFrame(stream, stream_id)

        self.sendNetStreamDataStart(stream, stream_id)
        if type != BROADCAST_START:
            self.sendBlankVideoFrame(stream, stream_id)
        self.sendMetaData(stream, stream_id)
Exemple #14
0
def saveImg():
    from time import time as getTime
    '''获取上传的图片'''
    img = request.files['image']

    # 获取文件名
    fileName = secure_filename(img.filename)
    if '.' in fileName:
        imgType = '.' + fileName.rsplit('.')[-1]
    else:
        imgType = ''
    # 文件名用时间戳命名
    imgName = str(getTime()).replace('.', '') + imgType
    imgPath = os.path.join(baseDir, blogImgDir, imgName)
    url = os.path.join(blogImgDir, imgName)

    try:
        # 保存文件
        img.save(imgPath)
    except Exception as e:
        print(e)
        return {
            'status': 300,
            'msg': "图片上传失败",
        }
    '''数据处理及返回'''
    return {'status': 200, 'msg': "图片上传成功", 'url': url}
Exemple #15
0
    def updateCanvas(self, **option):
        currentTime = getTime()
        duration = currentTime - self.lastUpdateTime
        self.lastUpdateTime = currentTime
        step = self.updateStep
        self.makeCurrentCanvas()

        noSim = option.get('no_sim', False)

        if noSim:
            # self.runtime.stepSim( 0 )
            self.runtime.updateNodeMgr()

        else:
            self.runtime.stepSim(step)

        self.runtime.stepGC(100)
        self.delegate.onUpdate(step)

        forced = option.get('forced', self.alwaysForcedUpdate)
        # printTraceBack()
        # print 'update canvas: %.3f' % ( duration )
        if forced:
            self.forceUpdateGL()
        else:
            self.updateGL()
Exemple #16
0
    def commandPlay(self, info, _, file, start, length):
        stream = self.getStream(info[1][4])
        if stream is None: return

        self.log("%s - Playing: %s" % (self.address, file))  #debug

        stream.close()
        stream.channel_id = 5
        stream.time = getTime()

        if start is not None:
            stream.start = start
        if length is not None:
            stream.length = int(stream.start + length)

        try:
            stream.stream = Stream.createStream(stream.id, stream.channel_id,
                                                file, self.rtmp)
        except:
            self.sendNetStreamPlayStreamNotFound(stream, file)
            raise Exception, "Stream Not Found (%s)" % file

        if start > 0:
            self.seek(stream, start, BROADCAST_START)
        else:
            self.startBroadcast(stream, BROADCAST_START)
Exemple #17
0
 def instruction(self, instr, addText="", maxTime=180):
     mouse = event.Mouse()
     time = core.Clock()
     self.win.setMouseVisible(False)
     event.clearEvents(eventType='keyboard')
     instrObj = visual.TextStim(win=self.win,
                                text='',
                                font=u'Arial',
                                height=0.07,
                                alignText='center',
                                wrapWidth=1.8,
                                color=textColor)
     instrObj.setText(instr + addText)
     while not (event.getKeys(keyList=['space'])
                or sum(mouse.getPressed()) > 0):
         instrObj.setAutoDraw(True)
         self.win.flip()
         if time.getTime() > maxTime:
             break
         if event.getKeys(keyList=['escape']):
             core.quit()
     instrObj.setAutoDraw(False)
     core.wait(0.3)
     self.win.flip()
     core.wait(0.5)
Exemple #18
0
    def commandPlay(self, info, _, file, start, length):
        stream = self.getStream(info[1][4])
        if stream is None:
            return

        self.log("%s - Playing: %s" % (self.address, file))  # debug

        stream.close()
        stream.channel_id = 5
        stream.time = getTime()

        if start is not None:
            stream.start = start
        if length is not None:
            stream.length = int(stream.start + length)

        try:
            stream.stream = Stream.createStream(stream.id, stream.channel_id, file, self.rtmp)
        except:
            self.sendNetStreamPlayStreamNotFound(stream, file)
            raise Exception, "Stream Not Found (%s)" % file

        if start > 0:
            self.seek(stream, start, BROADCAST_START)
        else:
            self.startBroadcast(stream, BROADCAST_START)
Exemple #19
0
def saveImgs():
    from time import time as getTime
    '''获取上传的图片'''
    imgFiles = request.files

    urls = []
    for pos in imgFiles.keys():
        item = []
        # 获取文件名
        fileName = secure_filename(imgFiles[pos].filename)
        imgType = fileName.rsplit('.')[-1]
        # 文件名用时间戳命名,由于cpu速度太快,时间戳可能会重复,加上pos
        imgName = str(getTime()).replace('.', '') + pos + '.' + imgType
        imgPath = os.path.join(blogImgDir, imgName)
        try:
            # 保存文件
            imgFiles[pos].save(imgPath)
        except Exception as e:
            print(e)
            return {
                'status': 300,
                'msg': "图片上传失败",
            }
        item.append(pos)
        item.append(imgPath)
        urls.append(item)

    return {'status': 200, 'msg': "图片上传成功", 'urls': urls}
Exemple #20
0
def dataAvail(text):
    global conn
    global connected
    global dialstate
    global starttime
    if text.find("Serial connection established") != -1:
        dialstate = LOGGING
    if text.find("AP authentication succeeded") != -1 or text.find(
            "No auth is possible") != -1:
        dialstate = CONNECTING
    if text.find("ip-up finished") != -1:
        starttime = getTime()
        dialstate = CONNECTED
        connected = True
        system("echo \"`date` : pppd: ip-up finished\" >>/tmp/autorun.tmp")
        if config.plugins.xModem.altdns.value:
            setAltDNS()
    if text.find("Connect script failed") != -1:
        dialstate = NONE
        system(
            "echo \"`date` : pppd: connect script failed\" >>/tmp/autorun.tmp")
        conn.sendCtrlC()
    #if text.find("Connection terminated") != -1:
    if text.find("ip-down finished") != -1:
        dialstate = NONE
        conn.sendCtrlC()
        connected = False
        starttime = None
        system(
            "echo \"`date` : pppd: connection terminated\" >>/tmp/autorun.tmp")
Exemple #21
0
def dataAvail(text):
	global conn
	global connected
	global dialstate
	global starttime
	if text.find("Serial connection established") != -1:
		dialstate = LOGGING
	if text.find("AP authentication succeeded") != -1 or text.find("No auth is possible") != -1:
		dialstate = CONNECTING
	if text.find("ip-up finished") != -1:
		starttime = getTime()
		dialstate = CONNECTED
		connected = True
		system("echo \"`date` : pppd: ip-up finished\" >>/tmp/autorun.tmp")
		if config.plugins.xModem.altdns.value:
			setAltDNS()
	if text.find("Connect script failed") != -1:
		dialstate = NONE
		system("echo \"`date` : pppd: connect script failed\" >>/tmp/autorun.tmp")
		conn.sendCtrlC()
	#if text.find("Connection terminated") != -1:
	if text.find("ip-down finished") != -1:
		dialstate = NONE
		conn.sendCtrlC()
		connected = False
		starttime = None
		system("echo \"`date` : pppd: connection terminated\" >>/tmp/autorun.tmp")
Exemple #22
0
 def refresh(self):
     time = getTime()
     for stream in self.streams:
         if (not self.blocking()) and (stream is not None) and (stream.stream is not None) and (stream.sleep < time):
             if stream.caching is not None:
                 self.cacheFrames(stream)
             if (stream.caching is None) and (stream.paused is None) and (not stream.stopped):
                 self.play(stream, time)
Exemple #23
0
 def __init__(self, dmg: float, cooldown: int) -> None:
     """
     dmg      - wysokość obrażeń zadawanych przez broń\n
     cooldown - czas w ms między możliwością zadania obrażeń
     """
     self.dmg = dmg
     self.cooldown = cooldown / 1000  # konwersja s na ms
     self.lastAttack = getTime() - (self.cooldown)
Exemple #24
0
 def saveFile(self):
     filename = QFileDialog.getSaveFileName(self,(u"打开文件"),"",u"Data Files(*.txt);;Else Files(*.*)")
     
     self.file = open(filename,'a+')
     print >>self.file, u"[%s]"%str(getTime())
     for x in range(BOX_LEN):
         print >>self.file, self.my_box_array[x].getInformation()
     print >>self.file, BOX_DATA_SPLIT
Exemple #25
0
    def Update_Time(self):

        self.RunNr += 1
        self.dt = (getTime() - self.t0) - self.t
        self.t = getTime() - self.t0
        self.dt_avg = self.t / self.RunNr

        if self.PrintTime:
            InfoText = "Run#" + str(self.RunNr) + ": t=" + str(round(
                self.t, 2)) + " s | dt=" + str(round(self.dt * 1000,
                                                     2)) + " ms"
            if self.dt != 0:
                InfoText += " | FPS=" + str(round(1. / self.dt, 2)) + " Hz"
                if 1:
                    InfoText += " | FPS_Avg=" + str(round(1. / self.dt_avg,
                                                          2)) + " Hz"
            print InfoText
def menuQueryFile(eng, queryFile, rankingSize):
    eng = loadIndexWrapper(eng)

    if not queryFile:
        print("Please enter the path to the cfc query file using the -in argument")
        sys.exit(-1)

    print("ranking size: {}".format(rankingSize))

    MAPs = []
    recallPointsLst = []
    pAtTens = []
    times = []
    try:
        print("query id ; P@10 ; interpolated MAP ; time (s)")
        for query in eng.parser.parseQueryFile(queryFile):
            start = getTime()
            results, evalResults = eng.processQuery(query, rankingSize,
                    evaluate=True)
            end = getTime() - start

            MAPs.append(evalResults["MAP"])
            recallPointsLst.append(evalResults["recallPoints"])
            pAtTens.append(evalResults["P@10"])
            times.append(end)
            print("{:03d} ; {:.5f} ; {:.5f} ; {:.5f} "
                    .format(query.id, pAtTens[-1], MAPs[-1], times[-1]))
    except IOError as e:
        print("Could not open the cfc query file at: {}.".format(queryFile))
        print(e.message)
        sys.exit(-1)

    avgRecallPoints = Evaluator.getAverageRecallPoints(recallPointsLst)
    avgMAP = sum(MAPs) / len(MAPs)
    avgPAtTen = sum(pAtTens) / len(pAtTens)
    avgTime = sum(times) / len(times)
    print("\nAverages:")

    print("\tP@10: {:.5f}".format(avgPAtTen))
    print("\tinterpolated MAP: {:.5f}".format(avgMAP))
    print("\ttime: {:.5f} s".format(avgTime))

    print("\tinterpolated recall points (precision, recall):")
    for pair in avgRecallPoints:
        p, r = pair
        print("\t({:.5f}, {:.5f}),".format (p, r))
def run_solver(solver_binary_path,
               instance_id,
               instance_path,
               arguments,
               timeout=20):
    logging.info(
        f"Running {solver_binary_path} on instance {instance_path}: {arguments}, timeout={timeout}"
    )
    result_obj = {
        'instance_id': instance_id,
        'node_name': config.SMTLAB_NODE_NAME
    }
    time = Timer()

    timeout_ms = int(timeout * 1000.0)

    try:
        argument_array = json.loads(arguments)
        out = subprocess.check_output([solver_binary_path] + argument_array +
                                      [instance_path],
                                      timeout=timeout).decode('UTF-8').strip()
    except subprocess.TimeoutExpired:
        time.stop()
        result_obj['result'] = "timeout"
        result_obj['stdout'] = ""
        result_obj['runtime'] = timeout_ms
        logging.info(f"timeout, result is {result_obj}")
        return result_obj
    except subprocess.CalledProcessError as e:
        time.stop()
        result_obj['result'] = "error"
        result_obj['stdout'] = f"stdout: {e.stdout} stderr: {e.stderr}"
        result_obj['runtime'] = time.getTime_ms()
        logging.info(f"process exited with an error, result is {result_obj}")
        return result_obj

    time.stop()

    result_obj['stdout'] = out
    result_obj['runtime'] = time.getTime_ms()

    if "unsat" in out:
        result_obj['result'] = "unsat"
    elif "sat" in out:
        result_obj['result'] = "sat"
    elif time.getTime() >= timeout:
        # sometimes python's subprocess does not terminate eagerly
        result_obj['result'] = "timeout"
        result_obj['runtime'] = timeout_ms
    elif "unknown" in out:
        result_obj['result'] = "unknown"
    else:
        result_obj['result'] = "error"

    logging.info(f"result is {result_obj}")
    return result_obj
Exemple #28
0
	def getConnectTime(self):
		time = int(getTime() - self.starttime)
		s = time % 60
		m = (time / 60) % 60
		h = (time / 3600) % 24
		d = time / 86400
		text = "%02d:%02d:%02d" % (h, m, s)
		if d > 0:
			text = "%dd %s" % (d, text)
		return text
Exemple #29
0
 def getConnectTime(self):
     time = int(getTime() - self.starttime)
     s = time % 60
     m = (time / 60) % 60
     h = (time / 3600) % 24
     d = time / 86400
     text = "%02d:%02d:%02d" % (h, m, s)
     if d > 0:
         text = "%dd %s" % (d, text)
     return text
Exemple #30
0
 def refresh(self):
     time = getTime()
     for stream in self.streams:
         if (not self.blocking()) and (stream is not None) and (
                 stream.stream is not None) and (stream.sleep < time):
             if stream.caching is not None:
                 self.cacheFrames(stream)
             if (stream.caching is None) and (stream.paused is None) and (
                     not stream.stopped):
                 self.play(stream, time)
Exemple #31
0
	def __init__(self, session, constarttime = None, iface='ppp0'):
		Screen.__init__(self, session)

		self.starttime = constarttime
		if self.starttime is None:
			self.starttime = getTime()
		self.iface = iface
		if self.iface is None:
			self.iface = 'ppp0'
		self.Console = None
		#self.netmask = "255.255.255.255"
		self.getInterface(self.iface)
		#self.nameservers = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]

		self["key_red"] = Button(_("Cancel"))
		self["ifacetxt"] = Label(_("Interface:"))
		self["ifaceval"] = Label(self.iface)
		self["curtimetxt"] = Label(_("Current Time:"))
		self["contimetxt"] = Label(_("Connection Time:"))
		self["contimeval"] = Label(self.getConnectTime())
		self["localIPtxt"] = Label(_("Local IP:"))
		self["localIPval"] = Label("-.-.-.-")
		self["remoteIPtxt"] = Label(_("Remote IP:"))
		self["remoteIPval"] = Label("-.-.-.-")
		self["gatewaytxt"] = Label(_("Gateway:"))
		self["gatewayval"] = Label(self.getGateway())
		self["dnstxt"] = Label(_("Name Servers:"))
		#self["dnsval"] = Label(self.ConvertIP(self.nameservers[0], na=True) + self.ConvertIP(self.nameservers[1], prefix="; "))
		self["dnsval"] = Label(self.getNameservers())
		self["receivetxt"] = Label(_("Received"))
		self["transmittxt"] = Label(_("Transmited"))
		self["bytestxt"] = Label(_("Bytes:"))
		self["bytesRXval"] = Label("0")
		self["bytesTXval"] = Label("0")
		self["packettxt"] = Label(_("Packets:"))
		self["packetRXval"] = Label("0")
		self["packetTXval"] = Label("0")
		self["errortxt"] = Label(_("Errors:"))
		self["errorRXval"] = Label("0")
		self["errorTXval"] = Label("0")
		
		self.getStatistics(self.iface)

		self["actions"] = ActionMap(["SetupActions"], 
			{
				"cancel": self.close,
				"ok": self.close
			})

		self.clock_timer = eTimer()
		self.clock_timer.callback.append(self.clockLoop)

		self.onClose.append(self.__closed)
		self.onLayoutFinish.append(self.__layoutFinished)
Exemple #32
0
 def getActualMsgTimeStr(cls, timestamp):
     try:
         DAY_SECONDS = 86400
         currentTime = getTime()
         if currentTime - timestamp > DAY_SECONDS or gmtime(
         ).tm_mday != gmtime(timestamp).tm_mday:
             return TimeFormatter.getShortTimeDateFormat(timestamp)
         return TimeFormatter.getShortTimeFormat(timestamp)
     except Exception:
         _logger.exception(
             'There is error while formatting message time: %r', timestamp)
Exemple #33
0
 def getActualMsgTimeStr(cls, timestamp):
     try:
         DAY_SECONDS = 86400
         currentTime = getTime()
         if currentTime - timestamp > DAY_SECONDS or gmtime(
         ).tm_mday != gmtime(timestamp).tm_mday:
             return TimeFormatter.getShortTimeDateFormat(timestamp)
         return TimeFormatter.getShortTimeFormat(timestamp)
     except Exception:
         LOG_ERROR('There is error while formatting message time',
                   timestamp)
         LOG_CURRENT_EXCEPTION()
Exemple #34
0
    def __init__(self, session, constarttime=None, iface='ppp0'):
        Screen.__init__(self, session)

        self.starttime = constarttime
        if self.starttime is None:
            self.starttime = getTime()
        self.iface = iface
        if self.iface is None:
            self.iface = 'ppp0'
        self.Console = None
        #self.netmask = "255.255.255.255"
        self.getInterface(self.iface)
        #self.nameservers = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]

        self["key_red"] = Button(_("Cancel"))
        self["ifacetxt"] = Label(_("Interface:"))
        self["ifaceval"] = Label(self.iface)
        self["curtimetxt"] = Label(_("Current Time:"))
        self["contimetxt"] = Label(_("Connection Time:"))
        self["contimeval"] = Label(self.getConnectTime())
        self["localIPtxt"] = Label(_("Local IP:"))
        self["localIPval"] = Label("-.-.-.-")
        self["remoteIPtxt"] = Label(_("Remote IP:"))
        self["remoteIPval"] = Label("-.-.-.-")
        self["gatewaytxt"] = Label(_("Gateway:"))
        self["gatewayval"] = Label(self.getGateway())
        self["dnstxt"] = Label(_("Name Servers:"))
        #self["dnsval"] = Label(self.ConvertIP(self.nameservers[0], na=True) + self.ConvertIP(self.nameservers[1], prefix="; "))
        self["dnsval"] = Label(self.getNameservers())
        self["receivetxt"] = Label(_("Received"))
        self["transmittxt"] = Label(_("Transmited"))
        self["bytestxt"] = Label(_("Bytes:"))
        self["bytesRXval"] = Label("0")
        self["bytesTXval"] = Label("0")
        self["packettxt"] = Label(_("Packets:"))
        self["packetRXval"] = Label("0")
        self["packetTXval"] = Label("0")
        self["errortxt"] = Label(_("Errors:"))
        self["errorRXval"] = Label("0")
        self["errorTXval"] = Label("0")

        self.getStatistics(self.iface)

        self["actions"] = ActionMap(["SetupActions"], {
            "cancel": self.close,
            "ok": self.close
        })

        self.clock_timer = eTimer()
        self.clock_timer.callback.append(self.clockLoop)

        self.onClose.append(self.__closed)
        self.onLayoutFinish.append(self.__layoutFinished)
Exemple #35
0
 def dataAvail(self, text):
     if text.find("unrecognized option") != -1:
         pos = text.find("unrecognized option")
         tmp1 = "pppd: " + text[pos:]
         tmp1 = tmp1[:tmp1.find("\n") + 1]
         tmp = self["state"].getText()
         tmp += self.dots + "FAILED\n"
         tmp += tmp1
         self["state"].setText(tmp)
     if text.find("Serial connection established") != -1:
         tmp = self["state"].getText()
         dots = self.dots[:-self.dot]
         tmp += dots + "OK\nLogin:"******"state"].setText(tmp)
     if text.find("Using interface") != -1:
         pos = text.find("Using interface")
         length = len("Using interface ")
         tmp = text[pos + length:]
         self.connectiface = tmp[:4]
     if text.find("AP authentication succeeded") != -1 or text.find(
             "No auth is possible") != -1:
         tmp = self["state"].getText()
         dots = self.dots[:-self.dot]
         tmp += dots + "..OK\n"
         self.dot = 0
         self["state"].setText(tmp)
         self.stateTimer.stop()
     if text.find("ip-up finished") != -1:
         global connected
         global starttime
         self.stateTimer.stop()
         if starttime == None:
             starttime = getTime()
         if config.plugins.xModem.altdns.value:
             setAltDNS()
         tmp = self["state"].getText()
         tmp += "Connected :)\n"
         self["state"].setText(tmp)
         self.red_function = DISCONNECT
         connected = True
     if text.find("Connect script failed") != -1:
         tmp = self["state"].getText()
         dots = self.dots[:-self.dot]
         tmp += dots + "FAILED\n"
         self["state"].setText(tmp)
         self.stateTimer.stop()
         self.red_function = NONE
         self.green_function = CONNECT
         self.disconnect()
     self.updateGui()
def loadData(catalog, category_ctg):
    """
    Carga los datos de los archivos y cargar los datos en la
    estructura de datos
    """
    delta_time = -1.0
    delta_memory = -1.0

    tracemalloc.start()
    start_time = time.getTime()
    start_memory = tracemalloc.getMemory()

    loadvideo(catalog)
    loadCategory_id(category_ctg)

    stop_memory = tracemalloc.getMemory()
    stop_time = time.getTime()
    tracemalloc.stop()

    delta_time = stop_time - start_time
    delta_memory = deltaMemory(start_memory, stop_memory)

    return delta_time, delta_memory
Exemple #37
0
	def dataAvail(self, text):
		if text.find("unrecognized option") != -1:
			pos = text.find("unrecognized option")
			tmp1 = "pppd: " + text[pos:]
			tmp1 = tmp1[:tmp1.find("\n")+1]
			tmp = self["state"].getText()
			tmp += self.dots + "FAILED\n"
			tmp += tmp1
			self["state"].setText(tmp)
		if text.find("Serial connection established") != -1:
			tmp = self["state"].getText()
			dots = self.dots[:-self.dot]
			tmp += dots + "OK\nLogin:"******"state"].setText(tmp)
		if text.find("Using interface") != -1:
			pos = text.find("Using interface")
			length = len("Using interface ")
			tmp = text[pos+length:]
			self.connectiface = tmp[:4]
		if text.find("AP authentication succeeded") != -1 or text.find("No auth is possible") != -1:
			tmp = self["state"].getText()
			dots = self.dots[:-self.dot]
			tmp += dots + "..OK\n";
			self.dot = 0
			self["state"].setText(tmp)
			self.stateTimer.stop()
		if text.find("ip-up finished") != -1:
			global connected
			global starttime
			self.stateTimer.stop()
			if starttime == None:
				starttime = getTime()
			if config.plugins.xModem.altdns.value:
				setAltDNS()
			tmp = self["state"].getText()
			tmp += "Connected :)\n"
			self["state"].setText(tmp)
			self.red_function = DISCONNECT
			connected=True
		if text.find("Connect script failed") != -1:
			tmp = self["state"].getText()
			dots = self.dots[:-self.dot]
			tmp += dots + "FAILED\n"
			self["state"].setText(tmp)
			self.stateTimer.stop()
			self.red_function = NONE
			self.green_function = CONNECT
			self.disconnect()
		self.updateGui()
Exemple #38
0
	def demande_coup(self):
		Start = getTime() 
		self.Nbr_Simulated_Moves = 0
		Possible_Moves = self.jeu.plateau.liste_coups_valides(Cl_val(self.couleur))
		
		if len(Possible_Moves) == 0 :
			return []

		BestScore = -float("inf")
		Chosen_Move = []
		print(self.couleur, " : ")
		for Move in Possible_Moves :
			Tmp_Board = self.jeu.plateau.copie()
			Tmp_Board.jouer(Move, Cl_val(self.couleur))
			self.Nbr_Simulated_Moves += 1
			Score = self.alpha_beta(Tmp_Board, 3, False, Cl_val(self.couleur))
			print("\t", Move, " ==> ", Score)
			if BestScore <= Score :
				BestScore = Score
				Chosen_Move = Move
		End = getTime()
		print("\n\tChosen Move ==> ", Chosen_Move, " after ", self.Nbr_Simulated_Moves, " simulations (",End-Start," s )")
		return Chosen_Move
 def __init__(self,
              scene,
              image,
              x,
              y,
              width,
              height,
              calque=1,
              time=0,
              pause=0):
     GameObject.__init__(self, scene, image, x, y, calque, width, height)
     self.scene.addEvent(self)
     self.time = time
     self.ctime = getTime()
Exemple #40
0
    def getText(self):
        time = self.source.time
        t = localtime(time)
        tnow = getTime()
        if time is None:
            return ''
        else:

            def fix_space(string):
                if 'Proportional' in self.fix and t.tm_hour < 10:
                    return ' ' + string
                if 'NoSpace' in self.fix:
                    return string.lstrip(' ')
                return string

            if self.type == self.SKY_AS_LENGTH:
                if time <= 9:
                    return ''
                elif time / 3600 < 1:
                    return ngettext('%d Min', '%d Mins', time / 60) % (time / 60)
                elif time / 60 % 60 == 0:
                    return ngettext('%d Hour', '%d Hours', time / 3600) % (time / 3600)
                else:
                    return '%dh %2dm' % (time / 3600, time / 60 % 60)
            if int(strftime('%H', t)) >= 12:
                timesuffix = _('pm')
            else:
                timesuffix = _('am')
            if self.type == self.DEFAULT:
                return fix_space(_('%2d:%02d') % (t.tm_hour, t.tm_min))
            if self.type == self.SKY_Q_DATE:
                d = _('%A, %l.%M') + _(timesuffix)
            elif self.type == self.SKY_HD_DATE:
                d = _('%l.%M') + _(timesuffix) + _(' %a %d/%m')
            elif self.type == self.SKY_HD_TIME:
                d = _('%l.%M') + _(timesuffix)
            elif self.type == self.SKY_Q_STARTTIME:
                if time < tnow:
                    d = _('Started at ') + _('%l.%M').lstrip(' ') + _(timesuffix)
                else:
                    d = _('Starts at ') + _('%l.%M').lstrip(' ') + _(timesuffix)
            elif self.type == self.SKY_HD_ENDTIME:
			d = _("-  %l.%M") + _(timesuffix)

            elif self.type == self.FORMAT:
                d = self.fmt_string
            else:
                return '???'
            timetext = strftime(d, t)
            return timetext.lstrip(' ')
Exemple #41
0
def menuInteractiveQuery(eng, rankingSize):
    eng = loadIndexWrapper(eng)

    qId = 1
    while True:
        try:
            queryString = raw_input(">> ")
        except EOFError:
            print('')
            break
        except KeyboardInterrupt:
            print('')
            break
        query = Query(qId, queryString, [])

        start = getTime()
        results, evalResults = eng.processQuery(query, rankingSize)
        print("It took {} s to process the query.".format(getTime() - start))

        for result in results:
            similarity, doc = result
            print("similarity: {}. id: {}".format(similarity, doc.id))
            print("\ttitle: {}".format(doc.title))
            print("\tauthors: {}, year: {}\n".format(doc.authors, doc.year))
Exemple #42
0
 def __init__(self, id):
     self.id = id
     self.time = getTime()
     self.stream = None
     self.buffer_time = 100
     self.start_time = 0.0
     self.cur_time = 0
     self.duration = None
     self.channel_id = 0
     self.paused = None
     self.stopped = False
     self.seek_pause = False
     self.seek_time = 0
     self.seek_index = 0
     self.caching = None
     self.sleep = 0.0
     self.blocked = None
     self.start = 0.0
     self.length = 0.0
	def updateCanvas( self, **option ):
		currentTime = getTime()
		step = currentTime - self.lastUpdateTime
		self.lastUpdateTime = currentTime
		
		step = self.updateStep #>>>>>>

		runtime = self.runtime
		runtime.setBufferSize( self.viewWidth, self.viewHeight )

		if not option.get( 'no_sim', False ):	
			runtime.updateStepSim( step )
		# 	getAKU().updateFMOD()

		self.delegate.onUpdate( step )
		if option.get( 'forced', self.alwaysForcedUpdate ):
			self.forceUpdateGL()
		else:
			self.updateGL()
Exemple #44
0
    def updateCanvas(self, **option):
        currentTime = getTime()
        step = currentTime - self.lastUpdateTime
        self.lastUpdateTime = currentTime

        step = self.updateStep  #>>>>>>

        runtime = self.runtime
        runtime.setBufferSize(self.viewWidth, self.viewHeight)

        if not option.get('no_sim', False):
            runtime.updateStepSim(step)
        # 	getAKU().updateFMOD()

        self.delegate.onUpdate(step)
        if option.get('forced', self.alwaysForcedUpdate):
            self.forceUpdateGL()
        else:
            self.updateGL()
Exemple #45
0
 def __init__(self, id):
     self.id = id
     self.time = getTime()
     self.stream = None
     self.buffer_time = 100
     self.start_time = 0.0
     self.cur_time = 0
     self.duration = None
     self.channel_id = 0
     self.paused = None
     self.stopped = False
     self.seek_pause = False
     self.seek_time = 0
     self.seek_index = 0
     self.caching = None
     self.sleep = 0.0
     self.blocked = None
     self.start = 0.0
     self.length = 0.0
Exemple #46
0
    def play(self, stream, time):
        if stream.blocked is not None:
            stream.start_time += time - stream.blocked
            stream.blocked = None

        rel_time = int((time - stream.start_time) * 1000.0) + (stream.buffer_time * 2)

        while rel_time > stream.cur_time:
            frame = stream.stream.getFrame()

            if (frame is None) or ((stream.length > 0) and (frame[0] > stream.length)):
                self.stop(stream)
                return
            else:

                stream.cur_time = frame[0]
                self.writeMessage(frame[1])

                if self.blocking():
                    stream.blocked = getTime()
                    return
Exemple #47
0
	def getText(self):
		seek = self.getSeek()
		if seek is None:
			return ""
		if self.type == self.TYPE_SUMMARY or self.type == self.TYPE_SUMMARY:
			s = self.position / 90000
			e = (self.length / 90000) - s
			return "%02d:%02d +%2dm" % (s/60, s%60, e/60)

		l = self.length
		p = self.position
		r = self.length - self.position  # Remaining

		if l < 0:
			return ""

		if not self.detailed:
			l /= 90000
			p /= 90000
			r /= 90000

		if self.negate: l = -l
		if self.negate: p = -p
		if self.negate: r = -r

		if l >= 0:
			sign_l = ""
		else:
			l = -l
			sign_l = "-"

		if p >= 0:
			sign_p = ""
		else:
			p = -p
			sign_p = "-"

		if r >= 0:
			sign_r = ""
		else:
			r = -r
			sign_r = "-"

		if self.type < 5:
			if config.usage.elapsed_time_positive_osd.value:
				sign_p = "+"
				sign_r = "-"
				sign_l = ""
			else:
				sign_p = "-"
				sign_r = "+"
				sign_l = ""

			if config.usage.swap_media_time_display_on_osd.value == "1":  # Mins
				if self.type == self.TYPE_LENGTH:
					return ngettext("%d Min", "%d Mins", (l/60)) % (l/60)
				elif self.type == self.TYPE_POSITION:
					if config.usage.swap_time_remaining_on_osd.value == "1": # Elapsed
						return sign_p + ngettext("%d Min", "%d Mins", (p/60)) % (p/60)
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						return sign_p + "%d  " % (p/60) + sign_r + ngettext("%d Min", "%d Mins", (r/60)) % (r/60)
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return sign_r + "%d  " % (r/60) + sign_p + ngettext("%d Min", "%d Mins", (p/60)) % (p/60)
					else:
						return sign_r + ngettext("%d Min", "%d Mins", (r/60)) % (r/60)
				elif self.type == self.TYPE_REMAINING:
					if config.usage.swap_time_remaining_on_osd.value == "1": # Elapsed
						return sign_p + ngettext("%d Min", "%d Mins", (p/60)) % (p/60)
					elif config.usage.swap_time_remaining_on_osd.value == "2" or config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return ""
					else:
						return sign_r + ngettext("%d Min", "%d Mins", (r/60)) % (r/60)
			elif config.usage.swap_media_time_display_on_osd.value == "2":  # Mins Secs
				if self.type == self.TYPE_LENGTH:
						return sign_l + "%d:%02d" % (l/60, l%60)
				elif self.type == self.TYPE_POSITION:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/60, p%60)
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d  " % (p/60, p%60) + sign_r + "%d:%02d" % (r/60, r%60)
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d  " % (r/60, r%60) + sign_p + "%d:%02d" % (p/60, p%60)
					else:
						return sign_r + "%d:%02d" % (r/60, r%60)
				elif self.type == self.TYPE_REMAINING:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/60, p%60)
					elif config.usage.swap_time_remaining_on_osd.value == "2" or config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return ""
					else:
						return sign_r + "%d:%02d" % (r/60, r%60)
			elif config.usage.swap_media_time_display_on_osd.value == "3":  # Hours Mins
				if self.type == self.TYPE_LENGTH:
					return sign_l + "%d:%02d" % (l/3600, l%3600/60)
				elif self.type == self.TYPE_POSITION:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/3600, p%3600/60)
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d  " % (p/3600, p%3600/60) + sign_r + "%d:%02d" % (r/3600, r%3600/60)
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d  " % (r/3600, r%3600/60) + sign_p + "%d:%02d" % (p/3600, p%3600/60)
					else:
						return sign_r + "%d:%02d" % (r/3600, r%3600/60)
				elif self.type == self.TYPE_REMAINING:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/3600, p%3600/60)
					elif config.usage.swap_time_remaining_on_osd.value == "2" or config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return ""
					else:
						return sign_r + "%d:%02d" % (r/3600, r%3600/60)
			elif config.usage.swap_media_time_display_on_osd.value == "4":  # Hours Mins Secs
				if self.type == self.TYPE_LENGTH:
					return sign_l + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
				elif self.type == self.TYPE_POSITION:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						return sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d:%02d  " % (p/3600, p%3600/60, p%60) + sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d:%02d  " % (r/3600, r%3600/60, r%60) + sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
					else:
						return sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
				elif self.type == self.TYPE_REMAINING:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						return sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
					elif config.usage.swap_time_remaining_on_osd.value == "2" or config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return ""
					else:
						return sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
			elif config.usage.swap_media_time_display_on_osd.value == "5":  # Percentage
				if self.type == self.TYPE_LENGTH:
					return sign_l + "%d:%02d" % (l/3600, l%3600/60)
				elif self.type == self.TYPE_POSITION:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						try:
							return sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						try:
							return sign_p + "%d%%  " % ((float(p + 0.0) / float(l + 0.0)) * 100) + sign_r + "%d%%" % ((float(r + 0.0) / float(l + 0.0)) * 100 + 1)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						try:
							return sign_r + "%d%%  " % ((float(r + 0.0) / float(l + 0.0)) * 100 +1 ) + sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					else:
						try:
							return sign_r + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
				elif self.type == self.TYPE_REMAINING:
					test = 0
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						try:
							return sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_osd.value == "2" or config.usage.swap_time_remaining_on_osd.value == "3": # Elapsed & Remaining
						return ""
					else:
						try:
							return sign_r + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""

			else: # Skin Setting
				if not self.detailed:
					if self.showHours:
						if self.showNoSeconds and self.showNoSeconds2:
							if self.type == self.TYPE_LENGTH:
								return sign_l + "%d:%02d" % (l/3600, l%3600/60)
							elif self.type == self.TYPE_POSITION:
								return sign_p + "%d:%02d" % (p/3600, p%3600/60)
							elif self.type == self.TYPE_REMAINING:
								return sign_r + "%d:%02d" % (r/3600, r%3600/60)
						else:
							if self.type == self.TYPE_LENGTH:
								return sign_l + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
							elif self.type == self.TYPE_POSITION:
								return sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
							elif self.type == self.TYPE_REMAINING:
								return sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
					else:
						if self.showNoSeconds:
							if self.type == self.TYPE_LENGTH:
								return ngettext("%d Min", "%d Mins", (l/60)) % (l/60)
							elif self.type == self.TYPE_POSITION:
								return sign_p + ngettext("%d Min", "%d Mins", (p/60)) % (p/60)
							elif self.type == self.TYPE_REMAINING and self.OnlyMinute:
								return ngettext("%d", "%d", (r/60)) % (r/60)
							elif self.type == self.TYPE_REMAINING:
								return sign_r + ngettext("%d Min", "%d Mins", (r/60)) % (r/60)
						elif self.showNoSeconds2:
							if self.type == self.TYPE_LENGTH:
								return ngettext("%d Min", "%d Mins", (l/60)) % (l/60)
							elif self.type == self.TYPE_POSITION:
								return sign_p + ngettext("%d Min", "%d Mins", (p/60)) % (p/60)
							elif self.type == self.TYPE_REMAINING and self.OnlyMinute:
								myRestMinuten = ngettext("%+6d", "%+6d", (r/60)) % (r/60)
								time = getTime()
								t = localtime(time)
								d = _("%-H:%M")
								return strftime(d, t) + myRestMinuten
							elif self.type == self.TYPE_REMAINING:
								return sign_r + ngettext("%d Min", "%d Mins", (r/60)) % (r/60)
						else:
							if self.type == self.TYPE_LENGTH:
								return sign_l + "%d:%02d" % (l/60, l%60)
							elif self.type == self.TYPE_POSITION:
								return sign_p + "%d:%02d" % (p/60, p%60)
							elif self.type == self.TYPE_REMAINING:
								return sign_r + "%d:%02d" % (r/60, r%60)
				else:
					if self.showHours:
						if self.type == self.TYPE_LENGTH:
							return sign_l + "%d:%02d:%02d:%03d" % ((l/3600/90000), (l/90000)%3600/60, (l/90000)%60, (l%90000)/90)
						elif self.type == self.TYPE_POSITION:
							return sign_r + "%d:%02d:%02d:%03d" % ((r/3600/90000), (r/90000)%3600/60, (r/90000)%60, (r%90000)/90)
						elif self.type == self.TYPE_REMAINING:
							return sign_p + "%d:%02d:%02d:%03d" % ((p/3600/90000), (p/90000)%3600/60, (p/90000)%60, (p%90000)/90)
					else:
						if self.type == self.TYPE_LENGTH:
							return sign_l + "%d:%02d:%03d" % ((l/60/90000), (l/90000)%60, (l%90000)/90)
						elif self.type == self.TYPE_POSITION:
							return sign_p + "%d:%02d:%03d" % ((p/60/90000), (p/90000)%60, (p%90000)/90)
						elif self.type == self.TYPE_REMAINING:
							return sign_r + "%d:%02d:%03d" % ((r/60/90000), (r/90000)%60, (r%90000)/90)

		else:
			if config.usage.elapsed_time_positive_vfd.value:
				sign_p = "+"
				sign_r = "-"
			else:
				sign_p = "-"
				sign_r = "+"
			if config.usage.swap_media_time_display_on_vfd.value == "1":  # Mins
				if self.type == self.TYPE_VFD_LENGTH:
					return ngettext("%d Min", "%d Mins", (l/60)) % (l/60)
				elif self.type == self.TYPE_VFD_POSITION:
					if config.usage.swap_time_remaining_on_vfd.value == "1": # Elapsed
						return sign_p + ngettext("%d Min", "%d Mins", (p/60)) % (p/60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						return sign_p + "%d  " % (p/60) + sign_r + ngettext("%d Min", "%d Mins", (r/60)) % (r/60)
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return sign_r + "%d  " % (r/60) + sign_p + ngettext("%d Min", "%d Mins", (p/60)) % (p/60)
					else:
						return sign_r + ngettext("%d Min", "%d Mins", (r/60)) % (r/60)
				elif self.type == self.TYPE_VFD_REMAINING:
					if config.usage.swap_time_remaining_on_vfd.value == "1": # Elapsed
						return sign_p + ngettext("%d Min", "%d Mins", (p/60)) % (p/60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2" or config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return ""
					else:
						return sign_r + ngettext("%d Min", "%d Mins", (r/60)) % (r/60)
			elif config.usage.swap_media_time_display_on_vfd.value == "2":  # Mins Secs
				if self.type == self.TYPE_VFD_LENGTH:
						return sign_l + "%d:%02d" % (l/60, l%60)
				elif self.type == self.TYPE_VFD_POSITION:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/60, p%60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d  " % (p/60, p%60) + sign_r + "%d:%02d" % (r/60, r%60)
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d  " % (r/60, r%60) + sign_p + "%d:%02d" % (p/60, p%60)
					else:
						return sign_r + "%d:%02d" % (r/60, r%60)
				elif self.type == self.TYPE_VFD_REMAINING:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/60, p%60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2" or config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return ""
					else:
						return sign_r + "%d:%02d" % (r/60, r%60)
			elif config.usage.swap_media_time_display_on_vfd.value == "3":  # Hours Mins
				if self.type == self.TYPE_VFD_LENGTH:
					return sign_l + "%d:%02d" % (l/3600, l%3600/60)
				elif self.type == self.TYPE_VFD_POSITION:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/3600, p%3600/60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d  " % (p/3600, p%3600/60) + sign_r + "%d:%02d" % (r/3600, r%3600/60)
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d  " % (r/3600, r%3600/60) + sign_p + "%d:%02d" % (p/3600, p%3600/60)
					else:
						return sign_r + "%d:%02d" % (r/3600, r%3600/60)
				elif self.type == self.TYPE_VFD_REMAINING:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/3600, p%3600/60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2" or config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return ""
					else:
						return sign_r + "%d:%02d" % (r/3600, r%3600/60)
			elif config.usage.swap_media_time_display_on_vfd.value == "4":  # Hours Mins Secs
				if self.type == self.TYPE_VFD_LENGTH:
					return sign_l + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
				elif self.type == self.TYPE_VFD_POSITION:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						return sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d:%02d  " % (p/3600, p%3600/60, p%60) + sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d:%02d  " % (r/3600, r%3600/60, r%60) + sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
					else:
						return sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
				elif self.type == self.TYPE_VFD_REMAINING:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						return sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2" or config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return ""
					else:
						return sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
			elif config.usage.swap_media_time_display_on_vfd.value == "5":  # Percentage
				if self.type == self.TYPE_VFD_LENGTH:
					return sign_l + "%d:%02d" % (l/3600, l%3600/60)
				elif self.type == self.TYPE_VFD_POSITION:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						try:
							return sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						try:
							return sign_p + "%d%%  " % ((float(p + 0.0) / float(l + 0.0)) * 100) + sign_r + "%d%%" % ((float(r + 0.0) / float(l + 0.0)) * 100 + 1)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						try:
							return sign_r + "%d%%  " % ((float(r + 0.0) / float(l + 0.0)) * 100 +1 ) + sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					else:
						try:
							return sign_r + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
				elif self.type == self.TYPE_VFD_REMAINING:
					test = 0
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						try:
							return sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_vfd.value == "2" or config.usage.swap_time_remaining_on_vfd.value == "3": # Elapsed & Remaining
						return ""
					else:
						try:
							return sign_r + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""


			else: # Skin Setting
				if not self.detailed:
					if self.showHours:
						if self.showNoSeconds:
							if self.type == self.TYPE_VFD_LENGTH:
								return sign_l + "%d:%02d" % (l/3600, l%3600/60)
							elif self.type == self.TYPE_VFD_POSITION:
								return sign_p + "%d:%02d" % (p/3600, p%3600/60)
							elif self.type == self.TYPE_REMAINING:
								return sign_r + "%d:%02d" % (r/3600, r%3600/60)
						else:
							if self.type == self.TYPE_VFD_LENGTH:
								return sign_l + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
							elif self.type == self.TYPE_VFD_POSITION:
								return sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
							elif self.type == self.TYPE_REMAINING:
								return sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
					else:
						if self.showNoSeconds:
							if self.type == self.TYPE_VFD_LENGTH:
								return ngettext("%d Min", "%d Mins", (l/60)) % (l/60)
							elif self.type == self.TYPE_VFD_POSITION:
								return sign_p + ngettext("%d Min", "%d Mins", (p/60)) % (p/60)
							elif self.type == self.TYPE_VFD_REMAINING:
								return sign_r + ngettext("%d Min", "%d Mins", (r/60)) % (r/60)
						else:
							if self.type == self.TYPE_VFD_LENGTH:
								return sign_l + "%d:%02d" % (l/60, l%60)
							elif self.type == self.TYPE_VFD_POSITION:
								return sign_p + "%d:%02d" % (p/60, p%60)
							elif self.type == self.TYPE_REMAINING:
								return sign_r + "%d:%02d" % (r/60, r%60)
				else:
					if self.showHours:
						if self.type == self.TYPE_VFD_LENGTH:
							return sign_l + "%d:%02d:%02d:%03d" % ((l/3600/90000), (l/90000)%3600/60, (l/90000)%60, (l%90000)/90)
						elif self.type == self.TYPE_VFD_POSITION:
							return sign_r + "%d:%02d:%02d:%03d" % ((r/3600/90000), (r/90000)%3600/60, (r/90000)%60, (r%90000)/90)
						elif self.type == self.TYPE_REMAINING:
							return sign_p + "%d:%02d:%02d:%03d" % ((p/3600/90000), (p/90000)%3600/60, (p/90000)%60, (p%90000)/90)
					else:
						if self.type == self.TYPE_VFD_LENGTH:
							return sign_l + "%d:%02d:%03d" % ((l/60/90000), (l/90000)%60, (l%90000)/90)
						elif self.type == self.TYPE_VFD_POSITION:
							return sign_p + "%d:%02d:%03d" % ((p/60/90000), (p/90000)%60, (p%90000)/90)
						elif self.type == self.TYPE_REMAINING:
							return sign_r + "%d:%02d:%03d" % ((r/60/90000), (r/90000)%60, (r%90000)/90)
Exemple #48
0
	def getClock(self):
		return getTime()
Exemple #49
0
	def getText(self):
		time = self.source.time
		if time is None:
			return ""

		duration = 0
		elapsed = 0
		remaining = 0

		if str(time[1]) != 'None':
			if self.type < 7:
				if config.usage.swap_time_remaining_on_osd.value == "0":
					(duration, remaining) = self.source.time
				elif config.usage.swap_time_remaining_on_osd.value == "1":
					(duration, elapsed) = self.source.time
				elif config.usage.swap_time_remaining_on_osd.value == "2":
					(duration, elapsed, remaining) = self.source.time
				elif config.usage.swap_time_remaining_on_osd.value == "3":
					(duration, remaining, elapsed) = self.source.time
			else:
				if config.usage.swap_time_remaining_on_vfd.value == "0":
					(duration, remaining) = self.source.time
				elif config.usage.swap_time_remaining_on_vfd.value == "1":
					(duration, elapsed) = self.source.time
				elif config.usage.swap_time_remaining_on_vfd.value == "2":
					(duration, elapsed, remaining) = self.source.time
				elif config.usage.swap_time_remaining_on_vfd.value == "3":
					(duration, remaining, elapsed) = self.source.time
		else:
			(duration, remaining) = self.source.time

		l = duration # Length
		p = elapsed # Position
		r = remaining  # Remaining

		sign_l = ""

		if self.type < 7:
			if config.usage.elapsed_time_positive_osd.value:
				sign_p = "+"
				sign_r = "-"
			else:
				sign_p = "-"
				sign_r = "+"
			if config.usage.swap_time_display_on_osd.value == "1":
				if remaining is not None:
					if config.usage.swap_time_remaining_on_osd.value == "1": # Elapsed
						return sign_p + ngettext(_("%d Min"), _("%d Mins"), (p/60)) % (p/60)
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						return sign_p + "%d  " % (p/60) + sign_r + ngettext(_("%d Min"), _("%d Mins"), (r/60)) % (r/60)
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return sign_r + "%d  " % (r/60) + sign_p + ngettext(_("%d Min"), _("%d Mins"), (p/60)) % (p/60)
					else:
						return sign_r + ngettext(_("%d Min"), _("%d Mins"), (r/60)) % (r/60)
				else:
					return ngettext(_("%d Min"), _("%d Mins"), (l/60)) % (l/60)

			elif config.usage.swap_time_display_on_osd.value == "2":
				if remaining is not None:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/60, p%60)
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d  " % (p/60, p%60) + sign_r + "%d:%02d" % (r/60, r%60)
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d  " % (r/60, r%60) + sign_p + "%d:%02d" % (p/60, p%60)
					else:
						return sign_r + "%d:%02d" % (r/60, r%60)
				else:
					return "%d:%02d" % (l/60, l%60)
			elif config.usage.swap_time_display_on_osd.value == "3":
				if remaining is not None:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/3600, p%3600/60)
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d  " % (p/3600, p%3600/60) + sign_r + "%d:%02d" % (r/3600, r%3600/60)
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d  " % (r/3600, r%3600/60) + sign_p + "%d:%02d" % (p/3600, p%3600/60)
					else:
						return sign_r + "%d:%02d" % (r/3600, r%3600/60)
				else:
					return sign_l + "%d:%02d" % (l/3600, l%3600/60)
			elif config.usage.swap_time_display_on_osd.value == "4":
				if remaining is not None:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						return sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d:%02d  " % (p/3600, p%3600/60, p%60) + sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d:%02d  " % (r/3600, r%3600/60, r%60) + sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
					else:
						return sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
				else:
					return sign_l + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
			elif config.usage.swap_time_display_on_osd.value == "5":
				if remaining is not None:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						try:
							return sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						try:
							return sign_p + "%d%%  " % ((float(p + 0.0) / float(l + 0.0)) * 100) + sign_r + "%d%%" % ((float(r + 0.0) / float(l + 0.0)) * 100 + 1)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						try:
							return sign_r + "%d%%  " % ((float(r + 0.0) / float(l + 0.0)) * 100 +1 ) + sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					else:
						try:
							return sign_r + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
				else:
					return sign_l + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
			else:
				if self.type == self.DEFAULT:
					if remaining is not None:
						if config.usage.swap_time_remaining_on_osd.value == "1": # Elapsed
							return sign_p + ngettext(_("%d Min"), _("%d Mins"), (p/60)) % (p/60)
						elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
							return sign_p + "%d  " % (p/60) + sign_r + ngettext(_("%d Min"), _("%d Mins"), (r/60)) % (r/60)
						elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
							return sign_r + "%d  " % (r/60) + sign_p + ngettext(_("%d Min"), _("%d Mins"), (p/60)) % (p/60)
						else:
							return sign_r + ngettext(_("%d Min"), _("%d Mins"), (r/60)) % (r/60)
					else:
						return ngettext(_("%d Min"), _("%d Mins"), (l/60)) % (l/60)
				elif self.type == self.ONLY_MINUTE:
					if remaining is not None:
						return ngettext(_("%d"), _("%d"), (r/60)) % (r/60)
				elif self.type == self.ONLY_MINUTE2:
					time = getTime()
					t = localtime(time)
					d = _("%-H:%M")
					if remaining is None:
						return strftime(d, t)
					if remaining is not None:
						if config.usage.elapsed_time_positive_vfd.value:
							myRestMinuten = "%+6d" % (r/60)
						else:
							myRestMinuten = "%+6d" % (r/60*-1)
						if (r/60) == 0:
							myRestMinuten = " "
						return strftime(d, t) + myRestMinuten
				elif self.type == self.WITH_SECONDS:
					if remaining is not None:
						if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
							return sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
						elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
							return sign_p + "%d:%02d:%02d  " % (p/3600, p%3600/60, p%60) + sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
						elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
							return sign_r + "%d:%02d:%02d  " % (r/3600, r%3600/60, r%60) + sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
						else:
							return sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
					else:
						return sign_l + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
				elif self.type == self.NO_SECONDS:
					if remaining is not None:
						if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
							return sign_p + "%d:%02d" % (p/3600, p%3600/60)
						elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
							return sign_p + "%d:%02d  " % (p/3600, p%3600/60) + sign_r + "%d:%02d" % (r/3600, r%3600/60)
						elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
							return sign_r + "%d:%02d  " % (r/3600, r%3600/60) + sign_p + "%d:%02d" % (p/3600, p%3600/60)
						else:
							return sign_r + "%d:%02d" % (r/3600, r%3600/60)
					else:
						return sign_l + "%d:%02d" % (l/3600, l%3600/60)
				elif self.type == self.IN_SECONDS:
					if remaining is not None:
						if config.usage.swap_time_remaining_on_osd.value == "1": # Elapsed
							return sign_p + "%d " % p
						elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
							return sign_p + "%d  " % p + sign_r + "%d " % r
						elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
							return sign_r + "%d  " % r + sign_p + "%d " % p
						else:
							return sign_r + "%d " % r
					else:
						return "%d " % l + _("Mins")
				elif self.type == self.PERCENTAGE:
					if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
						try:
							return sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
						try:
							return sign_p + "%d%%  " % ((float(p + 0.0) / float(l + 0.0)) * 100) + sign_r + "%d%%" % ((float(r + 0.0) / float(l + 0.0)) * 100 + 1)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
						try:
							return sign_r + "%d%%  " % ((float(r + 0.0) / float(l + 0.0)) * 100 +1 ) + sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					else:
						try:
							return sign_r + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
				else:
					return sign_l + "%d" % l

		else:
			if config.usage.elapsed_time_positive_vfd.value:
				sign_p = "+"
				sign_r = "-"
			else:
				sign_p = "-"
				sign_r = "+"
			if config.usage.swap_time_display_on_vfd.value == "1":
				if remaining is not None:
					if config.usage.swap_time_remaining_on_vfd.value == "1": # Elapsed
						return sign_p + ngettext(_("%d Min"), _("%d Mins"), (p/60)) % (p/60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						return sign_p + "%d  " % (p/60) + sign_r + ngettext(_("%d Min"), _("%d Mins"), (r/60)) % (r/60)
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return sign_r + "%d  " % (r/60) + sign_p + ngettext(_("%d Min"), _("%d Mins"), (p/60)) % (p/60)
					else:
						return sign_r + ngettext(_("%d Min"), _("%d Mins"), (r/60)) % (r/60)
				else:
					return ngettext(_("%d Min"), _("%d Mins"), (l/60)) % (l/60)

			elif config.usage.swap_time_display_on_vfd.value == "2":
				if remaining is not None:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/60, p%60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d  " % (p/60, p%60) + sign_r + "%d:%02d" % (r/60, r%60)
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d  " % (r/60, r%60) + sign_p + "%d:%02d" % (p/60, p%60)
					else:
						return sign_r + "%d:%02d" % (r/60, r%60)
				else:
					return "%d:%02d" % (l/60, l%60)
			elif config.usage.swap_time_display_on_vfd.value == "3":
				if remaining is not None:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						return sign_p + "%d:%02d" % (p/3600, p%3600/60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d  " % (p/3600, p%3600/60) + sign_r + "%d:%02d" % (r/3600, r%3600/60)
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d  " % (r/3600, r%3600/60) + sign_p + "%d:%02d" % (p/3600, p%3600/60)
					else:
						return sign_r + "%d:%02d" % (r/3600, r%3600/60)
				else:
					return sign_l + "%d:%02d" % (l/3600, l%3600/60)
			elif config.usage.swap_time_display_on_vfd.value == "4":
				if remaining is not None:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						return sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						return sign_p + "%d:%02d:%02d  " % (p/3600, p%3600/60, p%60) + sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						return sign_r + "%d:%02d:%02d  " % (r/3600, r%3600/60, r%60) + sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
					else:
						return sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
				else:
					return sign_l + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
			elif config.usage.swap_time_display_on_vfd.value == "5":
				if remaining is not None:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						try:
							return sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						try:
							return sign_p + "%d%%  " % ((float(p + 0.0) / float(l + 0.0)) * 100) + sign_r + "%d%%" % ((float(r + 0.0) / float(l + 0.0)) * 100 + 1)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						try:
							return sign_r + "%d%%  " % ((float(r + 0.0) / float(l + 0.0)) * 100 +1 ) + sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					else:
						try:
							return sign_r + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
				else:
					return sign_l + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
			else:
				if self.type == self.VFD:
					if remaining is not None:
						if config.usage.swap_time_remaining_on_vfd.value == "1": # Elapsed
							return sign_p + ngettext(_("%d Min"), _("%d Mins"), (p/60)) % (p/60)
						elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
							return sign_p + "%d  " % (p/60) + sign_r + ngettext(_("%d Min"), _("%d Mins"), (r/60)) % (r/60)
						elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
							return sign_r + "%d  " % (r/60) + sign_p + ngettext(_("%d Min"), _("%d Mins"), (p/60)) % (p/60)
						else:
							return sign_r + ngettext(_("%d Min"), _("%d Mins"), (r/60)) % (r/60)
					else:
						return ngettext(_("%d Min"), _("%d Mins"), (l/60)) % (l/60)
				elif self.type == self.VFD_WITH_SECONDS:
					if remaining is not None:
						if config.usage.swap_time_remaining_on_osd.value == "1":  # Elapsed
							return sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
						elif config.usage.swap_time_remaining_on_osd.value == "2": # Elapsed & Remaining
							return sign_p + "%d:%02d:%02d  " % (p/3600, p%3600/60, p%60) + sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
						elif config.usage.swap_time_remaining_on_osd.value == "3": # Remaining & Elapsed
							return sign_r + "%d:%02d:%02d  " % (r/3600, r%3600/60, r%60) + sign_p + "%d:%02d:%02d" % (p/3600, p%3600/60, p%60)
						else:
							return sign_r + "%d:%02d:%02d" % (r/3600, r%3600/60, r%60)
					else:
						return sign_l + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
				elif self.type == self.VFD_NO_SECONDS:
					if remaining is not None:
						if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
							return sign_p + "%d:%02d" % (p/3600, p%3600/60)
						elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
							return sign_p + "%d:%02d  " % (p/3600, p%3600/60) + sign_r + "%d:%02d" % (r/3600, r%3600/60)
						elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
							return sign_r + "%d:%02d  " % (r/3600, r%3600/60) + sign_p + "%d:%02d" % (p/3600, p%3600/60)
						else:
							return sign_r + "%d:%02d" % (r/3600, r%3600/60)
					else:
						return sign_l + "%d:%02d" % (l/3600, l%3600/60)
				elif self.type == self.VFD_IN_SECONDS:
					if remaining is not None:
						if config.usage.swap_time_remaining_on_vfd.value == "1": # Elapsed
							return sign_p + "%d " % p
						elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
							return sign_p + "%d  " % p + sign_r + "%d " % r
						elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
							return sign_r + "%d  " % r + sign_p + "%d " % p
						else:
							return sign_r + "%d " % r
					else:
						return "%d " % l + _("Mins")
				elif self.type == self.VFD_PERCENTAGE:
					if config.usage.swap_time_remaining_on_vfd.value == "1":  # Elapsed
						try:
							return sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_vfd.value == "2": # Elapsed & Remaining
						try:
							return sign_p + "%d%%  " % ((float(p + 0.0) / float(l + 0.0)) * 100) + sign_r + "%d%%" % ((float(r + 0.0) / float(l + 0.0)) * 100 + 1)
						except:
							return ""
					elif config.usage.swap_time_remaining_on_vfd.value == "3": # Remaining & Elapsed
						try:
							return sign_r + "%d%%  " % ((float(r + 0.0) / float(l + 0.0)) * 100 +1 ) + sign_p + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
					else:
						try:
							return sign_r + "%d%%" % ((float(p + 0.0) / float(l + 0.0)) * 100)
						except:
							return ""
				else:
					return sign_l + "%d" % l
Exemple #50
0
	def startUpdateTimer( self, fps ):
		step = 1000 / fps
		self.updateTimer.start( step )
		self.updateStep = 1.0/fps
		self.lastUpdateTime = getTime()
	def startUpdateTimer( self, fps = 60 ):
		self.enabled = True
		step = 1.0 / fps
		self.updateTimer.start( 1000 * step )
		self.updateStep = step
		self.lastUpdateTime = getTime()
    print("\tinterpolated MAP: {:.5f}".format(avgMAP))
    print("\ttime: {:.5f} s".format(avgTime))

    print("\tinterpolated recall points (precision, recall):")
    for pair in avgRecallPoints:
        p, r = pair
        print("\t({:.5f}, {:.5f}),".format (p, r))

if __name__ == '__main__':
    parser = createParser()
    args = parser.parse_args()
    eng = SearchEngine()

    if args.function == CREATE_INDEX_CMD:
        collectionFolder = args.path
        start = getTime()
        menuCreateIndex(eng, collectionFolder)
        print("It took {} s to create and save the index."
                .format(getTime() - start))

    elif args.function == INTERACTIVE_QUERY_CMD:
        rankingSize = args.rSize
        menuInteractiveQuery(eng, rankingSize)

    elif args.function == PROCESS_QUERY_FILE_CMD:
        queryFile = args.path
        rankingSize = args.rSize
        start = getTime()
        menuQueryFile(eng, queryFile, rankingSize)
        print("It took {} s to load the index and process all the queries."
                .format(getTime() - start))