示例#1
0
 def tick(self):
     """ advance the clock by one second """
     previous_hour = self._hours
     # super().tick()
     Clock.tick(self)
     if (self._hours < previous_hour):
         self.advance()
示例#2
0
 def now(cls, clock=None, zone=None):
     if clock is None and zone is None:
         return cls.now(Clock.system_default_zone())
     elif zone is None:
         return cls.now(Clock.system(zone))
     else:
         now = clock.instant()
         offset = clock.getZone().getRules().getOffset(now)
         return cls.of_epoch_second(now.get_epoch_second(), now.get_nano(), offset)
示例#3
0
def handle_ticktock_to_next_update(force):
    t = res_manager.get_next_update_time()
    if t < 0:
        return False
    else:
        if force:
            while Clock.get() < t:
                Clock.tick()
            return handle_ticktock(1)
        else:
            return handle_ticktock(t - Clock.get())
示例#4
0
class System(object):
    def reset(self, seed=None):
        self.feq = FutureEventsQueue()
        self.clock = Clock()
        self.stats = Stats()
        if seed is not None:
            random.seed(seed)
        self.initialize()
        
    def update_averages(self, overall_stats):
        for stat in self.stats:
            overall_stats.add(stat, self.stats.get(stat))

    def run(self, trials, duration, seed=None):
        overall_stats = Stats()
        for i in range(trials):
            self.reset(seed)
            while self.feq.has_events():
                event = self.feq.next_event()
                self.clock.update(event.time)
                if self.clock.has_run(duration):
                    break
                self.update()
                self.handle(event)
            self.finalize()
            self.update_averages(overall_stats)
            print "Completed trial %d/%d" % (i+1, trials)
        print
        return overall_stats
        
    def schedule_event(self, event):
        """ Convenience function """
        self.feq.schedule_event(event)
        
    def initialize(self):
        """ System-specific variables are initialized here and the
            first event is scheduled """
        pass
        
    def update(self):
        """ Anything that must be updated every single iteration
            regardless of event type goes here
        """
        pass
        
    def handle(self, event):
        """ Updating of system state and stats, and scheduling of next event
            should go here """
        pass

    def finalize(self):
        """ All final calculations go here before the stats object is
            returned """
        pass
示例#5
0
def main():
    database = Database()
    alarmLog = AlarmLog()
    summarizer = Summarizer(database, alarmLog)
    clock = Clock(summarizer)
    alarmWriter = AlarmWriter(summarizer)
    driver1 = Driver(1, summarizer)

    clock.start()
    alarmWriter.start()
    driver1.start()
    sleep(1000)
示例#6
0
    def __init__(self,screen,bgcolor):
        screenHeight = screen.get_height()
        screenWidth = screen.get_width()
        targetHeight = HDMIClock.defaultHeight * screenHeight

        Clock.__init__(self,targetHeight,HDMIClock.defaultColor)

        width = self.clockFace.get_width()
        height = self.clockFace.get_height()

        self.dimensions = pygame.Rect((screenWidth-width)/2,(screenHeight-height)/2,width,height)
        self.screen = screen
        self.bgcolor = bgcolor
示例#7
0
def tick_or_tock():
    global __on_tick
    if not __on_tick:
        res_manager.changed_res_set.clear()
        res_manager.run_timer()
        __on_tick = True
        if len(__clock_tick_event_receiver) > 0:
            for receiver in __clock_tick_event_receiver:
                notify_id = sky_client.write((RECEIVER, "Event", receiver),fill_content_id=True)
                #sky_client.take(template=(TARGET, notify_id, '?'))
    else:
        res_manager.run_listener()
        Clock.tick()
        report()
        __on_tick = False
示例#8
0
def run_timer():
    clk = Clock.get()
    if clk not in timers:
        return
    callback_list = timers[clk]
    for callback in callback_list:
        callback()
示例#9
0
  def __init__(self, speed, *groups):
    BackgroundObject.__init__(self, (0, 0), speed, *groups)

    self.image = pygame.image.load('gfx/terrain/example_editor.png').convert_alpha()
    self.rect = pygame.Rect((0, app.screen_height - self.image.get_height()),
                            (0, 0))
    self.clock = Clock()
示例#10
0
 def reset(self, seed=None):
     self.feq = FutureEventsQueue()
     self.clock = Clock()
     self.stats = Stats()
     if seed is not None:
         random.seed(seed)
     self.initialize()
示例#11
0
def get_next_update_time():
    while len(timers) > 0:
        t = min(timers)
        if t < Clock.get():
            timers.pop(t, None)
        else:
            return t
    return -1
示例#12
0
def clockinit(args):
    POL = GPIO("480", "out")
    CLK = GPIO("481", "out")
    clock = Clock(CLK, POL)
    statestore = StateStore(clock)
    statestore.restore()
    nvramstore = NVRAMStore(clock)
    if args.require_nvram and not nvramstore.restore():
        print("Cannot read clock state from the NVRAM. Exiting...")
        sys.exit(1)
    if args.invert:
        clock.inverse = True
    if args.uninvert:
        clock.inverse = False
    if args.state:
        clock.setState(args.state)
    return (clock, statestore, nvramstore)
示例#13
0
文件: zgame.py 项目: jclopes/ZGame
    def run(self):
        """Method that starts the game running."""

        timeController = Clock(self.S_TURN)

        self.isRunning = True
        while self.isRunning:
            # start turn
            timeController.start()
            leftTime = self.S_TURN

            #TODO think if input should be processed inside the inner loop
            # process user input to Game
            self.iMngr.processUserInput(self)
            #isRunning = not self.iMngr.closedGame()

            while timeController.time_left() > self.S_UPDATE:
                #sync with remote
                self.nMngr.updateGame(self)

                # update state of the game
                self.uMngr.updateGame(self)
                #newState = self.readState()
                #self.world.update(newState)

            # play sounds
            self.sMngr.updateGame(self)
            # render
            self.gMngr.draw(timeController.time_left(), self)
            #self.worldView.draw()

            # sleep if necessary
            timeController.sleep()
示例#14
0
def report_xml(file_name="report.xml", clock=-1):
    cur = Clock.get()
    if clock < 0:
        clock += cur
    content = E.content(clock=str(clock))
    for name in pool:
        value = str(pool.get(name).get_value(clock))
        content.insert(0, E.feature(E.name(name), E.currentValue(value)))
    with open(file_name, "w") as fout:
        fout.write(tostring(content, encoding='utf-8', xml_declaration=True, pretty_print=True))
示例#15
0
    def get_value(self, clock=-1):
        cur = Clock.get()
        if clock < 0:
            clock = cur + clock

        if clock > cur or clock < 0:
            return None

        for item in reversed(self.value):
            if item[0] <= clock:
                return item[1]
示例#16
0
def get_value(value, v):
    if utils.is_callable(value):
        return value()
    elif value == "$self":
        return v
    elif value == "$clock":
        return Clock.get()
    elif utils.is_string(value) and value.startswith("$"):
        return res_manager.get(value[1:])
    else:
        return value
示例#17
0
class BackgroundImage(BackgroundObject):
  def __init__(self, speed, *groups):
    BackgroundObject.__init__(self, (0, 0), speed, *groups)

    self.image = pygame.image.load('gfx/terrain/example_editor.png').convert_alpha()
    self.rect = pygame.Rect((0, app.screen_height - self.image.get_height()),
                            (0, 0))
    self.clock = Clock()

  def update(self):
    delta_y = round(self.clock.frame_span() * self.speed / 1000)
    self.rect.move_ip(0, delta_y)
示例#18
0
class System(object):
    def reset(self, seed=None):
        self.feq = FutureEventsQueue()
        self.clock = Clock()
        self.stats = Stats()
        if seed is not None:
            random.seed(seed)
        self.initialize()
        
    def run(self, duration, seed=None):
        self.reset(seed)
        while self.feq.has_events():
            event = self.feq.next_event()
            self.clock.update(event.time)
            if self.clock.has_run(duration):
                break
            self.update()
            self.handle(event)
        return self.stats
        
    def schedule_event(self, event):
        """ Convenience function """
        self.feq.schedule_event(event)
        
    def initialize(self):
        """ System-specific variables are initialized here and the
            first event is scheduled """
        pass
        
    def update(self):
        """ Anything that must be updated every single iteration
            regardless of event type goes here
        """
        pass
        
    def handle(self, event):
        """ Updating of system state and stats, and scheduling of next event
            should go here """
        pass
示例#19
0
 def __init__(self, aSize):
     self.disc = Disc()
     self.memory = MainMemory(aSize)
     self.memoryManager = ContinuousAssignment(LogicalMemory(self.memory),self)
     self.handler = InterruptionHandler(self)
     self.cpu = Cpu(self.memoryManager,self.handler)
     self.scheduler = Scheduler(self.cpu)        
     self.clock = Clock()
     self.IO = io.IO(self)
     self.clock.addSuscribed(self.cpu)
     self.clock.addSuscribed(self.IO)
     self.clock.addSuscribed(self.handler)
     #tabla que contiene todos los pcb (k,v) => (pid,pcb)
     self.table = {}
示例#20
0
	def __init__(self):
		self.clock = Clock()
		self.logger = logging.getLogger('mats')
		self.accepting_new_quote = True
		self.accepting_new_trade = True
		self.ticker_handlers = {
			'incomplete_read': self.incomplete_read_handler,
			'ssl_error':  self.ssl_error_handler,
			'unknown_error': self.unknown_error_handler,
			'connected': self.connected_handler,
			'new_quote': self.new_quote_handler,
			'new_trade': self.new_trade_handler,
			'empty_watchlist': self.empty_watchlist_handler
		}
示例#21
0
class BackgroundObject(pygame.sprite.Sprite):
  def __init__(self, pos, speed, *groups):
    pygame.sprite.Sprite.__init__(self, *groups)
    self.rect = pygame.Rect(pos, (0, 0))
    self.speed = speed
    self.clock = Clock()

  def update(self):
    delta_y = round(self.clock.frame_span() * self.speed / 1000)
    self.rect.move_ip(0, delta_y)
    if self.rect.top >= app.screen_height:
      self.kill()
      del self

  def left(self):   return self.rect.left
  def right(self):  return self.rect.right
  def top(self):    return self.rect.top
  def bottom(self): return self.rect.bottom
示例#22
0
 def get_value_history(self):
     values = self.value
     clk = Clock.get()
     ret = [None] * clk
     if values is None or len(values) == 0:
         return
     idx = 0
     pre_value = None
     for time, value in values:
         while idx < time:
             ret[idx] = pre_value
             idx += 1
         pre_value = value
         if time < clk:
             ret[time] = value
     while idx < clk:
         ret[idx] = pre_value
         idx += 1
     return ret
示例#23
0
    def activate(self, ev):
        """ Instantiate the components and clock for the mode. 
        The event passed in argument contains data sent by the previous mode.
        For example, the LevelTransitionMode sends a GameStart event
        containing the next level number to the GameMode. This way, the GameMode
        knows which level to instantiate. The GameMode sends a GameWon event
        containing the score to the LevelTransitionMode so that it can be 
        displayed.
        Small drawback: to keep the code generic, ALL the components are given 
        in argument the mode's EM and the event. Some components may not need 
        the event, but we can't know in advance, so we pass it anyway.
        """
        em = self.em
        self.active_components = [comp(em, ev) for comp in self.components]
        self.clock = Clock(em)
        self.clock.start() # returns when the clock is turned off, ie transition or quit 

        self.em.clear() # this removes the clock and MSM from the EM subscribers
        self.active_components = [] # last ref to component instances is lost
        self.clock = None
示例#24
0
def main(srvHost, srvPort):
    w = dict()
    em = EventManager()
    nm = NetworkManager(em, w)
    FRAME_TIME = 0.2  # 200 ms
    c = Clock(FRAME_TIME)
    c.start()
    slept_time = 0.0
    nm.start(srvHost, srvPort)
    counter = 100
    exit = False
    while not exit:
        nm.update(slept_time + c.time_passed())
        counter -= 1
        if counter <= 0:
            exit = True
        slept_time = c.time_left()
        c.sleep()
        print "%s" % (counter * FRAME_TIME)
示例#25
0
文件: server.py 项目: jclopes/ZGame
def main():
    cliMngr = ClientManager()
    clock = Clock(FRAMETIME)

    clock.start()
    while True:
        state = '{"team":[[10,10]],[[10,20]]}'
        # check if there are new clients trying to conect
        cliMngr.receive_connections()
        # send game state to all clients
        cliMngr.broadcast(state)
        # read clients input while we can
        timeout = clock.time_left()
        cliMngr.read_incoming_msgs(timeout)
        # drop clients that are not responsive
        cliMngr.check_clients_liveness()

        clock.sleep()
示例#26
0
  def start (self):
    """Creates the socket and starts the threads"""

    try:
      self.piglow = PiGlow ()

    except IOError as e:

      if e[0] == errno.EACCES:
        print >> sys.stderr, "Permission denied, try running as root"
      else:
        print >> sys.stderr, "Unknown error accessing the PiGlow"

      sys.exit (1)

    self.piglow.all (0)

    self.clock = Clock (self.piglow)
    self.alert = Alert (self.piglow)
    self.in_progress = In_Progress (self.piglow)

    address = (self.cfg.HOST, self.cfg.PORT)

    serversock = socket (AF_INET, SOCK_STREAM)
    serversock.setsockopt (SOL_SOCKET, SO_REUSEADDR, 1)
    serversock.bind (address)
    serversock.listen (5)

    self.check_jobs_thread = Thread (None, self.check_jobs, None, ())
    self.socket_manager_thread = Thread (None, self.socket_manager, None, (serversock, ))

    self.start_threads ()

    while self.running == True:
      sleep (1)

    self.stop ()
示例#27
0
 def test_clocks_with_negative_hours_and_minutes(self):
     self.assertEqual(Clock(7, 32), Clock(-12, -268))
示例#28
0
class TheLoop:
	def __init__(self):
		self.clock = Clock()
		self.logger = logging.getLogger('mats')
		self.accepting_new_quote = True
		self.accepting_new_trade = True
		self.ticker_handlers = {
			'incomplete_read': self.incomplete_read_handler,
			'ssl_error':  self.ssl_error_handler,
			'unknown_error': self.unknown_error_handler,
			'connected': self.connected_handler,
			'new_quote': self.new_quote_handler,
			'new_trade': self.new_trade_handler,
			'empty_watchlist': self.empty_watchlist_handler
		}

	def loop(self):
		self.ticker_p, self.ticker_conn = self.launch_ticker()
		while True:
			self.loop_iter()
		
	def loop_iter(self):
		if not self.clock.is_market_open():
			self.logger.info('theloop: market is closed. killing ticker.')
			self.ticker_p.terminate()
			
			# block until ticker child has time to exit
			while self.ticker_p.is_alive():
				pass
			
			# now go to sleep
			self.go_to_sleep()
		elif not self.ticker_p.is_alive():
			self.ticker_p, self.ticker_conn = self.launch_ticker()

		if self.ticker_conn.poll():
			data = self.ticker_conn.recv()
			self.ticker_handlers[data.name](data)

	def ticker(self, conn):
		ticker = Ticker(conn)
		ticker.start()

	def launch_ticker(self):
		self.logger.info('theloop: spawning ticker child process')
		parent, child = Pipe()		
		p = Process(target=self.ticker, name='ticker', args=(child,))
		p.start()
		return (p, parent)

	def incomplete_read_handler(self, data):
		self.logger.error('theloop: ticker had incompleteread error, attempting to respawn ticker.')
		self.ticker_p, self.ticker_conn = self.launch_ticker()

	def ssl_error_handler(self, data):
		self.logger.error('theloop: ticker had ssl_error, attempting to respawn ticker.')
		self.ticker_p, self.ticker_conn = self.launch_ticker()

	def unknown_error_handler(self, data):
		self.logger.error('theloop: ticker had an unknown error, attempting to respawn ticker.')
		self.ticker_p, self.ticker_conn = self.launch_ticker()		

	def connected_handler(self, event):
		self.logger.info('theloop: ticker connected to stream')

	def go_to_sleep(self):
		secs = self.clock.secs_until_open()
		time_slept = time.time()

		self.logger.info('theloop: sleeping for ' + str(secs) + ' seconds.')
		time.sleep(secs)

		secs_asleep = time.time() - time_slept
		self.logger.info('theloop: waking up after ' + str(secs_asleep) + ' seconds')
		self.logger.info('theloop: attempting to respawn ticker.')

		self.ticker_p, self.ticker_conn = self.launch_ticker()

	def new_quote_handler(self, event):
		self.logger.debug('theloop: ticker reports new quote')

	def new_trade_handler(self, event):
		self.logger.debug('theloop: ticker reports new trade')

	def empty_watchlist_handler(self, event):
		self.logger.info('theloop: exiting.')
		exit(0)
示例#29
0
 def test_clocks_an_hour_apart(self):
     self.assertNotEqual(Clock(14, 37), Clock(15, 37))
示例#30
0
 def test_clocks_with_hour_overflow_by_several_days(self):
     self.assertEqual(Clock(3, 11), Clock(99, 11))
示例#31
0
 def test_clocks_with_negative_hour(self):
     self.assertEqual(Clock(22, 40), Clock(-2, 40))
示例#32
0
 def test_clocks_with_negative_hour_that_wraps_multiple_times(self):
     self.assertEqual(Clock(13, 49), Clock(-83, 49))
示例#33
0
 def test_subtract_more_than_two_days(self):
     self.assertEqual(str(Clock(2, 20) - 3000), '00:20')
示例#34
0
 def test_sixty_minutes_is_next_hour(self):
     self.assertEqual(str(Clock(1, 60)), '02:00')
示例#35
0
 def test_hour_rolls_over_continuously(self):
     self.assertEqual(str(Clock(100, 0)), '04:00')
示例#36
0
 def test_hour_rolls_over(self):
     self.assertEqual(str(Clock(25, 0)), '01:00')
示例#37
0
 def test_full_clock_and_zeroed_clock(self):
     self.assertEqual(Clock(24, 0), Clock(0, 0))
示例#38
0
 def test_clocks_with_negative_hours_and_minutes_that_wrap(self):
     self.assertEqual(Clock(18, 7), Clock(-54, -11513))
示例#39
0
 def test_minutes_roll_over_continuously(self):
     self.assertEqual(str(Clock(0, 1723)), '04:43')
示例#40
0
 def test_clocks_with_negative_minute_that_wraps(self):
     self.assertEqual(Clock(4, 10), Clock(5, -1490))
示例#41
0
 def test_subtract_more_than_two_hours(self):
     self.assertEqual(str(Clock(0, 0) - 160), '21:20')
示例#42
0
 def test_clocks_with_minute_overflow(self):
     self.assertEqual(Clock(0, 1), Clock(0, 1441))
示例#43
0
 def test_clocks_with_negative_hour_that_wraps(self):
     self.assertEqual(Clock(17, 3), Clock(-31, 3))
示例#44
0
 def test_past_the_hour(self):
     self.assertEqual(str(Clock(11, 9)), '11:09')
示例#45
0
 def test_subtract_across_midnight(self):
     self.assertEqual(str(Clock(0, 3) - 4), '23:59')
示例#46
0
 def test_clocks_a_minute_apart(self):
     self.assertNotEqual(Clock(15, 36), Clock(15, 37))
示例#47
0
 def test_clocks_with_hour_overflow(self):
     self.assertEqual(Clock(10, 37), Clock(34, 37))
示例#48
0
class Kernel:
    def __init__(self, aSize):
        self.disc = Disc()
        self.memory = MainMemory(aSize)
        self.memoryManager = ContinuousAssignment(LogicalMemory(self.memory),self)
        self.handler = InterruptionHandler(self)
        self.cpu = Cpu(self.memoryManager,self.handler)
        self.scheduler = Scheduler(self.cpu)        
        self.clock = Clock()
        self.IO = io.IO(self)
        self.clock.addSuscribed(self.cpu)
        self.clock.addSuscribed(self.IO)
        self.clock.addSuscribed(self.handler)
        #tabla que contiene todos los pcb (k,v) => (pid,pcb)
        self.table = {}

    def getLogicalMemory(self):
        return self.logicalMemory

    def getMemoryManager(self):
        return self.memoryManager

    def getDisc(self):
        return self.disc

    def getCpu(self):
        return self.cpu

    def getMemory(self):
        return self.memory

    def getMemoryManager(self):
        return self.memoryManager

    def getHandler(self):
        return self.handler

    def getIO(self):
        return self.IO

    def getClock(self):
        return self.clock

    def getScheduler(self):
        return self.scheduler

    def getTable(self):
        return self.table

    #Comienza con la ejecucion del clock
    def startUp(self):
        self.getClock().startUp()

    #Corta la ejecucion del clock
    def shutDown(self):
        self.getClock().shutDown()

    def run(self, name):
        print "[Kernel] Ejecutar programa: " + str(name)
        self.handler.newIrq(name)

    #Obtiene todos los programas del disco
    def getProgramasDelDisco(self, name):
        return self.getDisc().getProgram(name)

    #Agrega el pcb en la table
    def addPcb(self,aPcb):
        self.table[aPcb.getPid()] = aPcb
        print "LALALALAAAAA " + str(len(self.table))

    #Borra el pcb en la table
    def removePcb(self,aPcb):
        #guardo las keys para tener una lista
        #y ver si la tabla de pcb esta vacia o no
        keys = self.table.keys()
        if(len(keys) != 0):
            del self.table[aPcb.getPid()]

        print "RERERERERER " + str(len(self.table))
示例#49
0
 def test_midnight_is_zero_hours(self):
     self.assertEqual(str(Clock(24, 0)), '00:00')
示例#50
0
 def test_clocks_with_negative_minute(self):
     self.assertEqual(Clock(2, 40), Clock(3, -20))
示例#51
0
 def test_subtract_more_than_one_day(self):
     self.assertEqual(str(Clock(5, 32) - 1500), '04:32')
示例#52
0
 def test_clocks_with_negative_minute_that_wraps_multiple_times(self):
     self.assertEqual(Clock(6, 15), Clock(6, -4305))
示例#53
0
def get(data, return_type=None):
    if type(data) is not dict or "method" not in data:
        if return_type is None:
            return data
        elif return_type == "lambda":
            return lambda: data
        else:
            return None

    method = data["method"]
    parameter = data["parameter"]

    if method.startswith(MATH_PREFIX):
        if method == METHOD_MATH_ADD:
            a = get(parameter["a"])
            b = get(parameter["b"])
            method = lambda value: get_value(a, value) + get_value(b, value)
        elif method == METHOD_MATH_DIVISION:
            a = get(parameter["a"])
            b = get(parameter["b"])
            method = lambda value: get_value(a, value) / get_value(b, value)
        elif method == METHOD_MATH_MINUS:
            a = get(parameter["a"])
            b = get(parameter["b"])
            method = lambda value: get_value(a, value) - get_value(b, value)
        elif method == METHOD_MATH_MULTIPLY:
            a = get(parameter["a"])
            b = get(parameter["b"])
            method = lambda value: get_value(a, value) * get_value(b, value)
        elif method == METHOD_MATH_MOD:
            a = get(parameter["a"])
            b = get(parameter["b"])
            method = lambda value: get_value(a, value) % get_value(b, value)
        elif method == METHOD_MATH_LINEAR:
            a = get(parameter["a"])
            b = get(parameter["b"])
            x = get(parameter["x"])
            method = lambda value: get_value(a, value) * get_value(x, value) + get_value(b, value)
        elif method == METHOD_MATH_SIN:
            a = get(parameter["a"])
            b = get(parameter["b"])
            x = get(parameter["x"])
            method = lambda value: get_value(a, value) * math.sin(get_value(x, value)) + get_value(b, value)
        elif method == METHOD_MATH_LOG:
            a = get(parameter["a"])
            b = get(parameter["b"])
            x = get(parameter["x"])
            method = lambda value: get_value(a, value) * math.log(get_value(x, value)) + get_value(b, value)
        elif method == METHOD_MATH_MEAN:
            terms = parameter["term"]
            method = lambda value: 1.0 * sum([get_value(term, value) for term in terms]) / len(terms)
        elif method == METHOD_MATH_SUM:
            terms = parameter["term"]
            #print terms
            method = lambda value: sum([get_value(term, value) for term in terms])
        else:
            print "not support method:", method
    elif method.startswith(PROBABILITY_PREFIX):
        if method == METHOD_PROBABILITY_MARKOV_CHAIN:
            state_set = parameter["state_set"]
            init_state = parameter["init_state"]
            trans_matrix = parameter["trans_matrix"]
            method = lambda value: markov_chain(value, state_set, init_state, trans_matrix)
        elif method == METHOD_PROBABILITY_NORMAL_VARIATE_RAND:
            mu = get(parameter["mu"])
            sigma = get(parameter["sigma"])
            method = lambda value: normalvariate(get_value(mu, value), get_value(sigma, value))
        elif method == METHOD_PROBABILITY_SIMPLE_RAND:
            min_value = get(parameter["min"])
            max_value = get(parameter["max"])
            method = lambda value: randint(get_value(min_value, value), get_value(max_value, value))
        else:
            print "not support method:", method
    else:
        if method == METHOD_OTHERS_COMBINE:
            sections = parameter["section"]
            # print "sections:", sections
            method = lambda value: dict((section, get_value(section, value)) for section in sections)
        elif method == METHOD_OTHERS_DATA_LIST:
            data_list = parameter["data_list"]
            method = lambda value: data_list[Clock.get() % len(data_list)]
        else:
            print "not support method:", method
    return method
示例#54
0
 def test_subtract_more_than_two_hours_with_borrow(self):
     self.assertEqual(str(Clock(6, 15) - 160), '03:35')
示例#55
0
 def test_hour_and_minutes_roll_over(self):
     self.assertEqual(str(Clock(25, 160)), '03:40')
示例#56
0
 def test_clocks_with_minute_overflow_by_several_days(self):
     self.assertEqual(Clock(2, 2), Clock(2, 4322))
示例#57
0
 def __init__(self, pos, speed, *groups):
   pygame.sprite.Sprite.__init__(self, *groups)
   self.rect = pygame.Rect(pos, (0, 0))
   self.speed = speed
   self.clock = Clock()
示例#58
0
 def test_hour_and_minutes_roll_over_continuously(self):
     self.assertEqual(str(Clock(201, 3001)), '11:01')
示例#59
0
 def test_minutes_roll_over(self):
     self.assertEqual(str(Clock(0, 160)), '02:40')
示例#60
0
 def test_clocks_with_same_time(self):
     self.assertEqual(Clock(15, 37), Clock(15, 37))