def on_event(self, event, topic): et = event.event_type ed = event.data if et == "motion": if ed == PirPhysicalSensor.ACTIVE and self._light == LightPhysicalSensor.DARK: if type(self._dark_timer) != type(9.0): log.warning("Timer is not set correctly") elif self._dark_timer + self._dark_timeout < get_time(): new_event = self.make_event(data=ed) self.publish(new_event) elif et == "light": op = None try: op = event.condition["threshold"]["operator"] except (KeyError, AttributeError): pass if op == ">": self._light = LightPhysicalSensor.BRIGHT self._dark_timer = None elif op == "<": self._light = LightPhysicalSensor.DARK self._dark_timer = get_time() else: log.warning("Unsupported structure in light event")
def on_event(self, event, topic): et = event.get_type() ed = event.get_raw_data() if et == "motion": if ed == PIRVirtualSensor.ACTIVE and self._light == LightVirtualSensor.DARK: if type(self._dark_timer) != type(9.0): log.warning("Timer is not set correctly") elif self._dark_timer + self._dark_timeout < get_time(): new_event = self.make_event_with_raw_data(ed, priority=self.DEFAULT_PRIORITY) self.publish(new_event) elif et == "light": op = None try: op = event.data["condition"]["threshold"]["operator"] except (KeyError, AttributeError): pass if op == ">": self._light = LightVirtualSensor.BRIGHT self._dark_timer = None elif op == "<": self._light = LightVirtualSensor.DARK self._dark_timer = get_time() else: log.warning("Unsupported structure in light event")
def read(self, ref): image_on_time = self.image_on_time inter_off_time = self.inter_off_time background = self.background_gray behaviour = self.behaviour traverse = VirtualCam.BEHAVE_TRAVERSE fade = VirtualCam.BEHAVE_FADE showing_img = self.showing_img move_image = self.move_image fps = self.fps num_images = self.total_images image_buffer = self.image_buffer[self.current_buffer] all_in_buffer = self.all_in_buffer start = get_time() run_time = start - self.on_off_start_time if not self.showing_img: if run_time >= inter_off_time: self.showing_img = True self.on_off_start_time = get_time() self.frame_number = 0 self.current_image_idx += 1 if self.current_image_idx >= num_images: self.current_image_idx = 0 if not all_in_buffer: self.current_buffer = int(not self.current_buffer) image_buffer = self.image_buffer[self.current_buffer] self.current_image[:] = image_buffer[self.current_image_idx] self.original_image[:] = image_buffer[self.current_image_idx] if behaviour == traverse or behaviour == fade: self.current_image[:] = background else: self.center_x = 0 self.center_y = 0 else: self.current_image[:] = background else: if run_time >= image_on_time: self.showing_img = False self.on_off_start_time = get_time() self.frame_number = 0 else: move_image(ref) self.frame_number += 1 self.prev_time = get_time() return True, self.current_image
def update(self, time_dif): self.ang_y += (Stupid.key_state(K_RIGHT) - Stupid.key_state(K_LEFT)) * time_dif self.ang_x += (Stupid.key_state(K_DOWN) - Stupid.key_state(K_UP)) * time_dif x = Stupid.key_state(K_d) - Stupid.key_state(K_a) y = Stupid.key_state(K_SPACE) - Stupid.key_state(K_LSHIFT) z = Stupid.key_state(K_s) - Stupid.key_state(K_w) cy = math.cos(self.ang_y) sy = math.sin(self.ang_y) cx = math.cos(self.ang_x) sx = math.sin(self.ang_x) move = vec() move.y = y * cx + z * sx move.x = x * cy - z * sy * cx + sy * sx * y move.z = x * sy + z * cy * cx - cy * sx * y if not Stupid.key_state(K_RCTRL): self.pos += time_dif * move * 5 else: self.stupid.candle.pos += time_dif * move * 5 # frame rate self.frame += 1 t = get_time() if t - self.time > 2: self.fps = self.frame / (t - self.time) self.time = t self.frame = 0
def __init__(self, emitter): FallbackSkill.__init__(self) self.config = ConfigurationManager.get()['padatious'] intent_cache = expanduser(self.config['intent_cache']) try: from padatious import IntentContainer except ImportError: LOG.error('Padatious not installed. Please re-run dev_setup.sh') try: call(['notify-send', 'Padatious not installed', 'Please run build_host_setup and dev_setup again']) except OSError: pass return ver = get_distribution('padatious').version if ver != PADATIOUS_VERSION: LOG.warning('Using Padatious v' + ver + '. Please re-run ' + 'dev_setup.sh to install ' + PADATIOUS_VERSION) self.container = IntentContainer(intent_cache) self.emitter = emitter self.emitter.on('padatious:register_intent', self.register_intent) self.emitter.on('padatious:register_entity', self.register_entity) self.register_fallback(self.handle_fallback, 5) self.finished_training_event = Event() self.train_delay = self.config['train_delay'] self.train_time = get_time() + self.train_delay self.wait_and_train()
def to_notification(self): return { 'key': self.key, 'sender': self.sender, 'msg': self.msg, 'sent': self.time or get_time() }
def _set(self, key, value, time): key = self.get_key(key) if time: expire = get_time() + time / 1000.0 else: expire = None value = self.encode_value(value) self.values[key] = (expire, value)
def policy_check(self, data): raw = data.get_raw_data() success = False if raw != self._last_value or self._report_timer is None or self._report_timer + self._report_threshold < get_time(): self._report_timer = get_time() success = True self._last_value = raw return success
def frame_rate_constraint(self, time_period): prev_time = get_time() lock = Lock() while self.running: curr_time = get_time() if curr_time - prev_time >= time_period: lock.acquire() try: self.locked = False finally: lock.release() #~ print(curr_time - prev_time) prev_time = curr_time self.locked = False
def update_model(self, name, file_name): if isfile(file_name): stat = os.stat(file_name) if get_time() - stat.st_mtime < self.update_freq * 60 * 60: return name = name.replace(' ', '%20') url = self.models_url + name self.download(url, file_name) self.download(url + '.params', file_name + '.params')
def _get(self, key, default): key = self.get_key(key) if key not in self.values: return default expire_time, value = self.values.get(key, default) if expire_time and expire_time <= get_time(): del self.values[key] return default return self.decode_value(value)
def evict(self): t = get_time() with self.lock: delete_keys = [] for k, (expire_time, v) in iteritems(self.values): if expire_time and expire_time <= t: delete_keys.append(k) for k in delete_keys: del self.values[k]
def wait_and_train(self): if not self.finished_initial_train: return sleep(self.train_delay) if self.train_time < 0.0: return if self.train_time <= get_time() + 0.01: self.train_time = -1.0 self.train()
def on_event(self, event, topic): et = event.get_type() ed = event.get_raw_data() if et != "motion": return if ed == PIRVirtualSensor.IDLE: self._inact_timer = get_time() else: self._inact_timer = None
def __exit__(self, *args, **kwargs): self.end_time = get_time() total_time = self.end_time - self.start_time # Skip timing on CI due to flakiness. if TRAVIS_CI or APPVEYOR: return if self.lower is not None: self.testcase.assertGreaterEqual(total_time, self.lower * (1.0 - TOLERANCE)) if self.upper is not None: self.testcase.assertLessEqual(total_time, self.upper * (1.0 + TOLERANCE))
def _get(self, key, default): path = self.make_path(self.get_key(key)) try: with self.fs.open(path, 'rb') as f: expire_time = f.readline().strip() if expire_time and float(expire_time) <= get_time(): self.fs.remove(path) return default value = self.decode_value(f.read()) return value except FSError: return default
def wait_and_train(self): sleep(self.train_delay) if self.train_time < 0.0: return if self.train_time <= get_time() + 0.01: self.train_time = -1.0 self.finished_training_event.clear() LOG.info('Training...') self.container.train() LOG.info('Training complete.') self.finished_training_event.set()
def _register_object(self, message, object_name, register_func): file_name = message.data['file_name'] name = message.data['name'] LOG.debug('Registering Padatious ' + object_name + ': ' + name) if not isfile(file_name): LOG.warning('Could not find file ' + file_name) return register_func(name, file_name) self.train_time = get_time() + self.train_delay self.wait_and_train()
def __exit__(self, *args, **kwargs): self.end_time = get_time() total_time = self.end_time - self.start_time # Skip timing on CI due to flakiness. if TRAVIS_CI: return if self.lower is not None: self.testcase.assertGreaterEqual(total_time, self.lower * (1.0 - TOLERANCE)) if self.upper is not None: self.testcase.assertLessEqual(total_time, self.upper * (1.0 + TOLERANCE))
def bind_engine(self, engine, priority=4): priority_skills = read_mycroft_config().get("skills", {}).get( "priority_skills", []) priority_skills.append(self.root_dir.split("/")[-1]) update_mycroft_config({"skills": {"priority_skills": priority_skills}}) self.priority = priority self.engine = engine self.config = engine.config self.register_messages(engine.name) self.register_fallback(self.handle_fallback, self.priority) self.finished_training_event = Event() self.finished_initial_train = False self.train_delay = self.engine.config.get('train_delay', 4) self.train_time = get_time() + self.train_delay
def cancel_all_pending_notifications(self): current_time = get_time() tasks_to_delete = [] for tasks_by_type in self._tasks.itervalues(): for task in tasks_by_type: if current_time < task.time: tasks_to_delete.append(task) else: break for task in tasks_to_delete: self.remove_task(task)
def mainloop(self): time = get_time() while 1: # event handling for event in pygame.event.get(): if event.type == QUIT: return elif event.type == KEYDOWN: if event.key == K_ESCAPE: return self.keys[event.key] = 1 elif event.type == KEYUP: self.keys[event.key] = 0 # update time_new = get_time() time_dif = time_new - time time = time_new for o in self.objects: o.update(time_dif) # render for o in self.objects: o.render() pygame.display.flip() sleep(0.005)
def bind_engine(self, engine, priority=4): conf = LocalConf(USER_CONFIG) priority_skills = Configuration.get().get("skills", {}).get( "priority_skills", []) priority_skills.append(self._dir.split("/")[-1]) conf.store() self.priority = priority self.engine = engine self.config = engine.config self.register_messages(engine.name) self.register_fallback(self.handle_fallback, self.priority) self.finished_training_event = Event() self.finished_initial_train = False self.train_delay = self.config.get('train_delay', 4) self.train_time = get_time() + self.train_delay
def evict(self): t = get_time() for path in self.fs.listdir(wildcard="*.cache"): try: with self.fs.open(path, 'rb') as f: try: expire_time = float(f.readline().strip()) except (TypeError, ValueError): # No expire time present, or format error continue if expire_time and expire_time <= t: self.fs.remove(path) except FSError: # Other processes may be evicting keys, so an FSError may not indicate a real problem pass
def add_timer(self, func: MessageFunc, chat_id: ChatId, interval: float, exec_time: float = None) -> MessageTimer: interval = float(interval) if exec_time is None: exec_time = get_time() + interval exec_time = float(exec_time) timer = MessageTimer(exec_time, interval, func, chat_id) self.timers.add(timer) return timer
def _set(self, key, value, time): path = self.make_path(self.get_key(key)) if time: expire = get_time() + time / 1000.0 else: expire = None value = self.encode_value(value) try: with self.fs.open(path, "wb") as f: if expire is None: f.write(b"\n") else: f.write(text_type(expire).encode("utf-8") + b"\n") f.write(value) except FSError: pass
def callback(function, wait, repeat=0): """ register a time based callback function :param function: pointer to a callback function :param wait: the amount of time to **wait** for the callback to execute. :param repeat: the number of times this callback should repeat (default 0) """ callbacks.append({ 'cb': function, 'time': get_time() + wait, 'wait': wait, 'repeat': repeat })
def _compile_metadata(self, hw): ww_module = self.hotword_engines[hw]["engine"].__class__.__name__ if ww_module == 'PreciseHotword': model_path = self.hotword_engines[hw]["engine"].precise_model with open(model_path, 'rb') as f: model_hash = md5(f.read()).hexdigest() else: model_hash = '0' return { 'name': self.hotword_engines[hw]["engine"].key_phrase.replace(' ', '-'), 'engine': md5(ww_module.encode('utf-8')).hexdigest(), 'time': str(int(1000 * get_time())), 'model': str(model_hash) }
def poll_latest(self): current_time = get_time() tasks = [] tasks_to_delete = [] for tasks_by_type in self._tasks.itervalues(): for task in tasks_by_type: if current_time < task.time: break tasks.append(task.to_notification()) tasks_to_delete.append(task) for task in tasks_to_delete: self.remove_task(task) return tasks
async def updateUserCount(self): """Update counter every few minutes""" await self.bot.wait_until_ready() try: await asyncio.sleep(20) # Start-up Time while True: servers = [ x for x in self.bot.servers if x.id in self.settings ] for server in servers: channels = self.settings[server.id]['channels'] userTotal = len(server.members) self.member_log = dataIO.load_json( 'data/clanlog/member_log.json') passed = (datetime.datetime.utcnow() - server.created_at).days await self.bot.edit_channel( server.get_channel(channels['member_channel']), name="{} Members".format( str(self.member_log[max(self.member_log.keys())]))) await self.bot.edit_channel( server.get_channel(channels['guests_channel']), name="{} Guests".format(await self.getUserCount( server, "Guest"))) if self.last_count != userTotal: current_time = get_time() self.discord_log[str(current_time)] = userTotal self.last_count = userTotal dataIO.save_json('data/clanlog/discord_log.json', self.discord_log) await self.bot.edit_channel( server.get_channel(channels['user_channel']), name="{} Total Users".format(userTotal)) await self.bot.edit_channel( server.get_channel(channels['server_channel']), name="{} Days Old".format(str(passed))) await asyncio.sleep(600) # task runs every 600 seconds except asyncio.CancelledError: pass
def update(self, step='next', time='now', **values): step = len(self.times) if step == 'next' else step time = get_time() if time == 'now' else time if self.cast_value: values = {k: self.cast_value(v) for (k, v) in values.items()} self.times[step] = time for metric, v in values.items(): if metric not in self.values: self._init_metric(metric) self.values[metric][step] = v # need to make sure all metrics have the same length for metric, vs in self.values.items(): if len(vs) < len(self.times): vs[len(self.times) - 1] = self.null_val
def _set(self, key, value, time): path = self.make_path(self.get_key(key)) if time: expire = get_time() + time / 1000.0 else: expire = None value = self.encode_value(value) try: with self.fs.open(path, 'wb') as f: if expire is None: f.write(b'\n') else: text_type(expire) f.write(text_type(expire).encode('utf-8') + b'\n') f.write(value) except FSError: pass
def policy_check(self, event): raw = event.data success = False # Conditionally report data first_attempt = self._last_report_time is None value_changed = not first_attempt and raw != self._last_value timer_expired = not first_attempt and (self._last_report_time + self._report_every < get_time()) if first_attempt or value_changed or timer_expired: self._last_report_time = get_time() log.debug("We %s have Internet access!" % ("DO" if raw else "DO NOT")) success = True self._last_value = raw return success
def __init__(self, bus, service): FallbackSkill.__init__(self, use_settings=False) if not PadatiousService.instance: PadatiousService.instance = self self.padatious_config = Configuration.get()['padatious'] self.service = service intent_cache = expanduser(self.padatious_config['intent_cache']) try: from padatious import IntentContainer except ImportError: LOG.error('Padatious not installed. Please re-run dev_setup.sh') try: call([ 'notify-send', 'Padatious not installed', 'Please run build_host_setup and dev_setup again' ]) except OSError: pass return self.container = IntentContainer(intent_cache) self._bus = bus self.bus.on('padatious:register_intent', self.register_intent) self.bus.on('padatious:register_entity', self.register_entity) self.bus.on('detach_intent', self.handle_detach_intent) self.bus.on('detach_skill', self.handle_detach_skill) self.bus.on('mycroft.skills.initialized', self.train) # Call Padatious an an early fallback, looking for a high match intent self.register_fallback(self.handle_fallback, PadatiousService.fallback_tight_match) # Try loose Padatious intent match before going to fallback-unknown self.register_fallback(self.handle_fallback_last_chance, PadatiousService.fallback_loose_match) self.finished_training_event = Event() self.finished_initial_train = False self.train_delay = self.padatious_config['train_delay'] self.train_time = get_time() + self.train_delay self.registered_intents = []
def _compile_metadata(self): ww_module = self.wake_word_recognizer.__class__.__name__ if ww_module == 'PreciseHotword': model_path = self.wake_word_recognizer.precise_model with open(model_path, 'rb') as f: model_hash = md5(f.read()).hexdigest() else: model_hash = '0' return { 'name': self.wake_word_name.replace(' ', '-'), 'engine': md5(ww_module.encode('utf-8')).hexdigest(), 'time': str(int(1000 * get_time())), 'sessionId': SessionManager.get().session_id, 'accountId': self.account_id, 'model': str(model_hash) }
def get_boosted_load(region: str, pool: str, current_load: float) -> float: """Return the load to use for autoscaling calculations, taking into account the computed boost, if any. This function will fail gracefully no matter what (returning the current load) so we don't block the autoscaler. """ try: zk_boost_path = get_zk_boost_path(region, pool) current_time = get_time() with ZookeeperPool() as zk: boost_values = get_boost_values(region, pool, zk) if current_time >= boost_values.end_time: # If there is an expected_load value, that means we've just completed # a boost period. Reset it to 0 if boost_values.expected_load > 0: zk.set(zk_boost_path + '/expected_load', '0'.encode('utf-8')) # Boost is no longer active - return current load with no boost return current_load # Boost is active. If expected load wasn't already computed, set it now. if boost_values.expected_load == 0: expected_load = current_load * boost_values.boost_factor log.debug( 'Activating boost, storing expected load: {} in ZooKeeper'. format(expected_load)) zk.ensure_path(zk_boost_path + '/expected_load') zk.set(zk_boost_path + '/expected_load', str(expected_load).encode('utf-8')) else: expected_load = boost_values.expected_load # We return the boosted expected_load, but only if the current load isn't greater. return expected_load if expected_load > current_load else current_load except Exception as e: # Fail gracefully in the face of ANY error log.error('get_boost failed with: {}'.format(e)) return current_load
def msg(*msg, v=4, time=False, memory=False, reset=False, end='\n', no_indent=False, t=None, m=None, r=None): """Write message to logging output. Log output defaults to standard output but can be set to a file by setting `sc.settings.log_file = 'mylogfile.txt'`. v : {'error', 'warn', 'info', 'hint'} or int, (default: 4) 0/'error', 1/'warn', 2/'info', 3/'hint', 4, 5, 6... time, t : bool, optional (default: False) Print timing information; restart the clock. memory, m : bool, optional (default: Faulse) Print memory information. reset, r : bool, optional (default: False) Reset timing and memory measurement. Is automatically reset when passing one of ``time`` or ``memory``. end : str (default: '\n') Same meaning as in builtin ``print()`` function. no_indent : bool (default: False) Do not indent for ``v >= 4``. """ # variable shortcuts if t is not None: time = t if m is not None: memory = m if r is not None: reset = r if isinstance(v, str): v = _VERBOSITY_LEVELS_FROM_STRINGS[v] if v == 3: # insert "--> " before hints msg = ('-->',) + msg if v >= 4 and not no_indent: msg = (' ',) + msg if _settings_verbosity_greater_or_equal_than(v): if not time and not memory and len(msg) > 0: _write_log(*msg, end=end) if reset: try: settings._previous_memory_usage, _ = get_memory_usage() except: pass settings._previous_time = get_time() if time: elapsed = get_passed_time() msg = msg + ('({})'.format(_sec_to_str(elapsed)),) _write_log(*msg, end=end) if memory: _write_log(get_memory_usage(), end=end)
def __init__(self, bus, service): FallbackSkill.__init__(self) if not PadatiousService.instance: PadatiousService.instance = self self.padatious_config = Configuration.get()['padatious'] self.service = service intent_cache = expanduser(self.padatious_config['intent_cache']) try: from padatious import IntentContainer except ImportError: LOG.error('Padatious not installed. Please re-run dev_setup.sh') try: call(['notify-send', 'Padatious not installed', 'Please run build_host_setup and dev_setup again']) except OSError: pass return self.container = IntentContainer(intent_cache) self._bus = bus self.bus.on('padatious:register_intent', self.register_intent) self.bus.on('padatious:register_entity', self.register_entity) self.bus.on('detach_intent', self.handle_detach_intent) self.bus.on('detach_skill', self.handle_detach_skill) self.bus.on('mycroft.skills.initialized', self.train) # Call Padatious an an early fallback, looking for a high match intent self.register_fallback(self.handle_fallback, PadatiousService.fallback_tight_match) # Try loose Padatious intent match before going to fallback-unknown self.register_fallback(self.handle_fallback_last_chance, PadatiousService.fallback_loose_match) self.finished_training_event = Event() self.finished_initial_train = False self.train_delay = self.padatious_config['train_delay'] self.train_time = get_time() + self.train_delay self.registered_intents = []
def exec_command(self, msg: tuple) -> bool: """ Executes command using message and arguments passed through the parameter :param msg: Tuple containing command and arguments :return: True if command was successfully executed """ command, args = parse_command(msg) try: if command == "EXIT": self.exit() return True elif command == 'USER_KEY_PRESS': self.process_key_input(args[0], args[1]) self.stats_cmd("DEBUG_TIME", [args[2], get_time()]) return True except IndexError: debug_out( "ERROR - Not enough arguments for the following command: " + "\nCommand: {}".format(command) + "\n{}".format(str(args))) return False
def _get(self, key, default): try: entry = self.entries.pop(key) except KeyError: return default # Remove entry from cache value_bytes = entry.value value_size =len(value_bytes) self.size -= value_size # If it has expired return the default if entry.expire_time and get_time() > entry.expire_time: return default # Otherwise put it back in to the cache at first position self.entries[key] = entry self.size += value_size return self.decode_value(value_bytes)
def _register_object(self, message, object_name, register_func): """Generic method for registering a padatious object. Arguments: message (Message): trigger for action object_name (str): type of entry to register register_func (callable): function to call for registration """ file_name = message.data['file_name'] name = message.data['name'] LOG.debug('Registering Padatious ' + object_name + ': ' + name) if not isfile(file_name): LOG.warning('Could not find file ' + file_name) return register_func(name, file_name) self.train_time = get_time() + self.train_delay self.wait_and_train()
def _upload_wake_word(self, audio): ww_module = self.wake_word_recognizer.__class__.__name__ if ww_module == 'PreciseHotword': model_path = self.wake_word_recognizer.precise_model with open(model_path, 'rb') as f: model_hash = md5(f.read()).hexdigest() else: model_hash = '0' metadata = { 'name': self.wake_word_name.replace(' ', '-'), 'engine': md5(ww_module.encode('utf-8')).hexdigest(), 'time': str(int(1000 * get_time())), 'sessionId': SessionManager.get().session_id, 'accountId': self.account_id, 'model': str(model_hash) } requests.post(self.upload_url, files={ 'audio': BytesIO(audio.get_wav_data()), 'metadata': StringIO(json.dumps(metadata)) })
def __init__(self, bus, service): FallbackSkill.__init__(self) if not PadatiousService.instance: PadatiousService.instance = self self.config = Configuration.get()['padatious'] self.service = service intent_cache = expanduser(self.config['intent_cache']) try: from padatious import IntentContainer except ImportError: LOG.error('Padatious not installed. Please re-run dev_setup.sh') try: call([ 'notify-send', 'Padatious not installed', 'Please run build_host_setup and dev_setup again' ]) except OSError: pass return self.container = IntentContainer(intent_cache) self._bus = bus self.bus.on('padatious:register_intent', self.register_intent) self.bus.on('padatious:register_entity', self.register_entity) self.bus.on('detach_intent', self.handle_detach_intent) self.bus.on('detach_skill', self.handle_detach_skill) self.bus.on('mycroft.skills.initialized', self.train) self.register_fallback(self.handle_fallback, 5) self.finished_training_event = Event() self.finished_initial_train = False self.train_delay = self.config['train_delay'] self.train_time = get_time() + self.train_delay self.registered_intents = []
def init(path, width=800, height=800, title='Predigame', bg=(220, 220, 220), fullscreen=False, collisions=True, **kwargs): global globs, RUN_PATH, WIDTH, HEIGHT, FPS, GRID_SIZE, SURF, FULLSCREEN, COLLISIONS, clock, start_time, sounds RUN_PATH = path WIDTH, HEIGHT = width, height FPS = kwargs.get('fps', 45) GRID_SIZE = kwargs.get('grid', 50) FULLSCREEN = fullscreen COLLISIONS = collisions pygame.mixer.pre_init(22050, -16, 2, 1024) # sound delay fix pygame.init() pygame.display.set_caption(title) SURF = display(None, DISPLAY_MAIN) clock = pygame.time.Clock() background(bg) globs = Globals(WIDTH, HEIGHT, GRID_SIZE, COLLISIONS) Globals.instance = globs loading_font = pygame.font.Font(None, 72) SURF.blit(loading_font.render('LOADING...', True, (235, 235, 235)), (25, 25)) pygame.display.update() images['__error__'] = pygame.image.load( os.path.join(os.path.dirname(__file__), 'images', 'error.png')) images['__screenshot__'] = pygame.image.load( os.path.join(os.path.dirname(__file__), 'images', 'screenshot.png')) start_time = get_time()
def _upload_wake_word(self, audio): ww_module = self.wake_word_recognizer.__class__.__name__ if ww_module == 'PreciseHotword': model_path = self.wake_word_recognizer.precise_model with open(model_path, 'rb') as f: model_hash = md5(f.read()).hexdigest() else: model_hash = '0' metadata = { 'name': self.wake_word_name.replace(' ', '-'), 'engine': md5(ww_module.encode('utf-8')).hexdigest(), 'time': str(int(1000 * get_time())), 'sessionId': SessionManager.get().session_id, 'accountId': self.account_id, 'model': str(model_hash) } requests.post( self.upload_url, files={ 'audio': BytesIO(audio.get_wav_data()), 'metadata': StringIO(json.dumps(metadata)) } )
def reset(**kwargs): global game_over, current_level, score_dict game_over = False current_level = None score_dict = {} destroyall() globs.keys_registered['keydown'] = {} globs.keys_registered['keyup'] = {} globs.tags = {} del globs.animations[:] del callbacks[:] if not kwargs.get('soft', False): Globals.cache = {} from . import api code, mod = load_module(RUN_PATH, api) exec(code, mod.__dict__) garbagecollect() global start_time start_time = get_time() resume()
def __init__(self, stupid): self.stupid = stupid fullscreen = False self.width, self.height = 1280, 800 self.ratio = float(self.width) / self.height pygame.display.gl_set_attribute(GL_STENCIL_SIZE, 4) pygame.display.gl_set_attribute(GL_MULTISAMPLESAMPLES, 4) pygame.display.gl_set_attribute(GL_MULTISAMPLEBUFFERS, 1) pygame.display.set_mode((self.width, self.height), OPENGL | DOUBLEBUF | (fullscreen and FULLSCREEN)) pygame.mouse.set_visible(False) glEnable(GL_MULTISAMPLE) glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST) glEnable(GL_LINE_SMOOTH) glEnable(GL_BLEND) glEnable(GL_ALPHA_TEST) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glDepthFunc(GL_LEQUAL) glEnable(GL_DEPTH_TEST) glEnable(GL_CULL_FACE) glShadeModel(GL_SMOOTH) glClearColor(0.2, 0.2, 0.2, 0) self.pos = vec(0, 5, 10) self.ang_y = 0 self.ang_x = 0.1 self.fps = 0 self.frame = 0 self.time = get_time()
async def clanlog(self, ctx, download=None): """Notifies whenever someone leaves or joins. Run this command on a schedule, do [p]clanlog download on first use.""" old_clans = deepcopy(await self.clans.getClans()) new_clans = deepcopy(old_clans) count = 0 for clankey in self.clans.keysClans(): try: clan = await self.clash.get_clan(await self.clans.getClanData(clankey, 'tag')) except clashroyale.RequestError: print("CLANLOG: Cannot reach Clash Royale Servers.") return count += clan.get("members") one_clan = {} for member in clan.member_list: tag = member.tag.strip("#") one_clan[tag] = {} one_clan[tag]["tag"] = tag one_clan[tag]["name"] = member.name one_clan[tag]["WarDayWins"] = 0 one_clan[tag]["cardsEarned"] = 0 if download is not None: await self.clans.addMember(clankey, member.name, tag) new_clans[clankey]['members'] = one_clan if download is not None: return if self.last_count != count: self.update_member_log() current_time = get_time() self.member_log[str(current_time)] = count self.last_count = count saved_times = list(self.member_log.keys()) for time in saved_times: if (current_time - float(time)) > 2678400: # one month self.member_log.pop(time, None) self.save_member_log() server = ctx.message.server for clankey in old_clans.keys(): for member in old_clans[clankey]["members"].keys(): if member not in new_clans[clankey]["members"]: memberName = old_clans[clankey]["members"][member]["name"] memberTag = old_clans[clankey]["members"][member]["tag"] await self.clans.delMember(clankey, memberTag) title = "{} (#{})".format(memberName, memberTag) desc = "left **{}**".format(old_clans[clankey]["name"]) embed_left = discord.Embed(title=title, url="https://royaleapi.com/player/{}".format(memberTag), description=desc, color=0xff0000) if server.id == "374596069989810176": channel = await self.clans.getClanData(clankey, 'log_channel') if channel is not None: try: await self.bot.send_message(discord.Object(id=channel), embed=embed_left) except discord.errors.NotFound: await self.bot.say("<#{}> NOT FOUND".format(channel)) except discord.errors.Forbidden: await self.bot.say("No Permission to send messages in <#{}>".format(channel)) await self.bot.say(embed=embed_left) for clankey in self.clans.keysClans(): for member in new_clans[clankey]["members"].keys(): if member not in old_clans[clankey]["members"]: memberName = new_clans[clankey]["members"][member]["name"] memberTag = new_clans[clankey]["members"][member]["tag"] await self.clans.addMember(clankey, memberName, memberTag) title = "{} (#{})".format(memberName, memberTag) desc = "joined **{}**".format(old_clans[clankey]["name"]) embed_join = discord.Embed(title=title, url="https://royaleapi.com/player/{}".format(memberTag), description=desc, color=0x00ff40) if server.id == "374596069989810176": channel = await self.clans.getClanData(clankey, 'log_channel') if channel is not None: try: await self.bot.send_message(discord.Object(id=channel), embed=embed_join) except discord.errors.NotFound: await self.bot.say("<#{}> NOT FOUND".format(channel)) except discord.errors.Forbidden: await self.bot.say("No Permission to send messages in <#{}>".format(channel)) await self.bot.say(embed=embed_join)
def set_boost_factor( zk_boost_path: str, region: str = '', pool: str = '', send_clusterman_metrics: bool = False, factor: float = DEFAULT_BOOST_FACTOR, duration_minutes: int = DEFAULT_BOOST_DURATION, override: bool = False, ) -> bool: """ Set a boost factor for a path in zk Can be used to boost either cluster or service autoscalers. If using for cluster you must specify region, pool and set send_clusterman_metrics=True so that clusterman metrics are updated otherwise just zk_boost_path is enough. """ if factor < MIN_BOOST_FACTOR: log.error(f'Cannot set a boost factor smaller than {MIN_BOOST_FACTOR}') return False if factor > MAX_BOOST_FACTOR: log.warning( 'Boost factor {} does not sound reasonable. Defaulting to {}'. format( factor, MAX_BOOST_FACTOR, )) factor = MAX_BOOST_FACTOR if duration_minutes > MAX_BOOST_DURATION: log.warning( 'Boost duration of {} minutes is too much. Falling back to {}.'. format( duration_minutes, MAX_BOOST_DURATION, )) duration_minutes = MAX_BOOST_DURATION current_time = get_time() end_time = current_time + 60 * duration_minutes if clusterman_metrics and send_clusterman_metrics: cluster = load_system_paasta_config().get_cluster() metrics_client = clusterman_metrics.ClustermanMetricsBotoClient( region_name=region, app_identifier=pool) with metrics_client.get_writer( clusterman_metrics.APP_METRICS) as writer: metrics_key = clusterman_metrics.generate_key_with_dimensions( 'boost_factor', { 'cluster': cluster, 'pool': pool }, ) writer.send((metrics_key, current_time, factor)) if duration_minutes > 0: writer.send((metrics_key, end_time, 1.0)) zk_end_time_path = zk_boost_path + '/end_time' zk_factor_path = zk_boost_path + '/factor' zk_expected_load_path = zk_boost_path + '/expected_load' with ZookeeperPool() as zk: if (not override and current_time < get_boost_values(zk_boost_path, zk).end_time): log.error('Boost already active. Not overriding.') return False try: zk.ensure_path(zk_end_time_path) zk.ensure_path(zk_factor_path) zk.ensure_path(zk_expected_load_path) zk.set(zk_end_time_path, str(end_time).encode('utf-8')) zk.set(zk_factor_path, str(factor).encode('utf-8')) zk.set(zk_expected_load_path, '0'.encode('utf-8')) except Exception: log.error('Error setting the boost in Zookeeper') raise log.info( 'Load boost: Set capacity boost factor {} at path {} until {}'. format( factor, zk_boost_path, datetime.fromtimestamp(end_time).strftime('%c'), )) # Let's check that this factor has been properly written to zk return get_boost_values(zk_boost_path, zk) == BoostValues( end_time=end_time, boost_factor=factor, expected_load=0, )
async def clublog(self, ctx, download=None): """Notifies whenever someone leaves or joins. Run this command on a schedule, do [p]clublog download on first use.""" old_clubs = deepcopy(await self.clubs.getClubs()) new_clubs = deepcopy(old_clubs) count = 0 for clubkey in self.clubs.keysClubs(): try: club = self.brawl.get_club(await self.clubs.getClubData(clubkey, 'tag')) except brawlstats.RequestError: print("CLANLOG: Cannot reach Brawl Stars Servers.") return count += club.members_count one_club = {} for member in club.members: tag = member.tag one_club[tag] = {} one_club[tag]["tag"] = tag one_club[tag]["name"] = member.name if download is not None: await self.clubs.addMember(clubkey, member.name, tag) new_clubs[clubkey]['members'] = one_club if download is not None: return if self.bs_last_count != count: self.update_bs_member_log() current_time = get_time() self.bs_member_log[str(current_time)] = count self.bs_last_count = count saved_times = list(self.bs_member_log.keys()) for time in saved_times: if (current_time - float(time)) > 2678400: # one month self.bs_member_log.pop(time, None) self.save_bs_member_log() server = ctx.message.server for clubkey in old_clubs.keys(): for member in old_clubs[clubkey]["members"].keys(): if member not in new_clubs[clubkey]["members"]: memberName = old_clubs[clubkey]["members"][member]["name"] memberTag = old_clubs[clubkey]["members"][member]["tag"] await self.clubs.delMember(clubkey, memberTag) title = "{} (#{})".format(await self.tags.formatName(memberName), memberTag) desc = "left **{}**".format(old_clubs[clubkey]["name"]) embed_left = discord.Embed(title=title, url="https://brawlstats.com/profile/{}".format(memberTag), description=desc, color=0xff0000) if server.id == "515502772926414933": channel = await self.clubs.getClubData(clubkey, 'log_channel') if channel is not None: try: await self.bot.send_message(discord.Object(id=channel), embed=embed_left) except discord.errors.NotFound: await self.bot.say("<#{}> NOT FOUND".format(channel)) except discord.errors.Forbidden: await self.bot.say("No Permission to send messages in <#{}>".format(channel)) await self.bot.say(embed=embed_left) for clubkey in self.clubs.keysClubs(): for member in new_clubs[clubkey]["members"].keys(): if member not in old_clubs[clubkey]["members"]: memberName = new_clubs[clubkey]["members"][member]["name"] memberTag = new_clubs[clubkey]["members"][member]["tag"] await self.clubs.addMember(clubkey, memberName, memberTag) title = "{} (#{})".format(await self.tags.formatName(memberName), memberTag) desc = "joined **{}**".format(old_clubs[clubkey]["name"]) embed_join = discord.Embed(title=title, url="https://brawlstats.com/profile/{}".format(memberTag), description=desc, color=0x00ff40) if server.id == "515502772926414933": channel = await self.clubs.getClubData(clubkey, 'log_channel') if channel is not None: try: await self.bot.send_message(discord.Object(id=channel), embed=embed_join) except discord.errors.NotFound: await self.bot.say("<#{}> NOT FOUND".format(channel)) except discord.errors.Forbidden: await self.bot.say("No Permission to send messages in <#{}>".format(channel)) await self.bot.say(embed=embed_join)
def tick(self): ticks = self.ticks time = get_time() ticks.append(time) while time - ticks[0] > self.UPDATE_INTERVAL: ticks.popleft()
def main(): print "--- main starts ---" startTime = time.get_time() myFile_power = "log/log_"+time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(startTime))+"_power.log" myFile_socket = "log/log_"+time.strftime("%Y_%m_%d_%H_%M_%S",time.localtime(startTime))+"_socket.log" bus.write_word_data(DEVICE_ADDRESS, 0x00, 0x9F08) print "power log file set to "+myFile_power print "socket log file set to "+myFile_socket with file(myFile_socket, "a+") as fd: fd.write("%.6f # # #\n" % startTime) print "--- running measureThread ----" thread_measure = measureThread(startTime, myFile_power) #thread_events = eventReadModule.EventLogThread(startTime) thread_measure.start() #thread_events.start() print "--- starting server ---" try: mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) host = "127.0.0.1" port = 40000 mySocket.bind((host, port)) mySocket.setblocking(1) mySocket.listen(5) print "Server started" while True: try: conn, addr = mySocket.accept() print "Got connection from:", addr receiveStr = conn.recv(1024) print "Received following message\n", receiveStr recordType, port, tmStr = receiveStr.split("|") process, pid = getProcessName(port) print "Got process name" nowTime = convert_time(tmStr) print "Time from gps:", str(tm) print "Got start time" strTime = "%.6f" % (nowTime - startTime) myArray_socket = [str(strTime), str(recordType), str(process), str(pid)] dummyArray = myArray_socket print "Array:",dummyArray print "Start writing " saveRecords_socket(dummyArray, myFile_socket) print "Record saved in file" except: print "Exception in socket communication" print "Close the socket" mySocket.close() raise except KeyboardInterrupt: #print "Exception message:"+ str(sys.exc_info()) print "Keyboard Interrupt occoured" thread_measure.stop() #thread_events.stop() print "Wait for threads to exit" thread_measure.join() #thread_events.join() except: print "Unexpected error:"+ str(sys.exc_info()) thread_measure.stop() #thread_events.stop() print "Wait for threads to exit" thread_measure.join() #thread_events.join() print "--- end of program ---"
def start(self, cell): self.generate(cell) self.playing = True self.initialTime = get_time() timer(self.update_time, 1000)
def create_header(user_obj): """ create_header(obj) -> return (None) creates the information heading for the file """ info = Description() time = Time() border = Format() title, description, version, author = get_user_input() user_obj.add_string(border.draw_border(1)) # create a string with following information time_str = "{} Created on the {} at {} hrs".format(border.draw_border(1), time.get_date(), time.get_time()) author_name = "{} Created by : {} ".format(border.draw_border(1), author) script_name = "{} Name of the program : {} ".format(border.draw_border(1), title) ver = "{} This is version : {} ".format(border.draw_border(1), version) val, script_description = info.get_script_description(description) # write the string to file user_obj.add_string(author_name.title()) user_obj.add_string(script_name.title()) user_obj.add_string(time_str) user_obj.add_string(ver) user_obj.add_string(border.draw_border(1)) user_obj.add_string(border.draw_border(1)) user_obj.add_string("{} File description ".format(border.draw_border(1))) user_obj.add_string(border.draw_border(1)) # write the main text to file if not val: user_obj.add_string("{} {}".format(border.draw_border(1), script_description)) else: for text in script_description: user_obj.add_string("{} {}".format(border.draw_border(1), text)) # finish of by creating the border user_obj.add_string(border.draw_border(1)) user_obj.add_string(border.draw_border(80))
def _wait_until_wake_word(self, source, sec_per_buffer, emitter): """Listen continuously on source until a wake word is spoken Args: source (AudioSource): Source producing the audio chunks sec_per_buffer (float): Fractional number of seconds in each chunk """ num_silent_bytes = int(self.SILENCE_SEC * source.SAMPLE_RATE * source.SAMPLE_WIDTH) silence = get_silence(num_silent_bytes) # bytearray to store audio in byte_data = silence buffers_per_check = self.SEC_BETWEEN_WW_CHECKS / sec_per_buffer buffers_since_check = 0.0 # Max bytes for byte_data before audio is removed from the front max_size = self.sec_to_bytes(self.SAVED_WW_SEC, source) test_size = self.sec_to_bytes(self.TEST_WW_SEC, source) said_wake_word = False # Rolling buffer to track the audio energy (loudness) heard on # the source recently. An average audio energy is maintained # based on these levels. energies = [] idx_energy = 0 avg_energy = 0.0 energy_avg_samples = int(5 / sec_per_buffer) # avg over last 5 secs ww_module = self.wake_word_recognizer.__class__.__name__ if ww_module == 'PreciseHotword': _, model_path = self.wake_word_recognizer.get_model_info() model_hash = check_output(['md5sum', model_path]).split()[0] else: model_hash = '0' counter = 0 while not said_wake_word and not self._stop_signaled: if self._skip_wake_word(): break chunk = self.record_sound_chunk(source) energy = self.calc_energy(chunk, source.SAMPLE_WIDTH) if energy < self.energy_threshold * self.multiplier: self._adjust_threshold(energy, sec_per_buffer) if len(energies) < energy_avg_samples: # build the average energies.append(energy) avg_energy += float(energy) / energy_avg_samples else: # maintain the running average and rolling buffer avg_energy -= float(energies[idx_energy]) / energy_avg_samples avg_energy += float(energy) / energy_avg_samples energies[idx_energy] = energy idx_energy = (idx_energy + 1) % energy_avg_samples # maintain the threshold using average if energy < avg_energy * 1.5: if energy > self.energy_threshold: # bump the threshold to just above this value self.energy_threshold = energy * 1.2 # Periodically output energy level stats. This can be used to # visualize the microphone input, e.g. a needle on a meter. if counter % 3: with open(self.mic_level_file, 'w') as f: f.write("Energy: cur=" + str(energy) + " thresh=" + str(self.energy_threshold)) f.close() counter += 1 # At first, the buffer is empty and must fill up. After that # just drop the first chunk bytes to keep it the same size. needs_to_grow = len(byte_data) < max_size if needs_to_grow: byte_data += chunk else: # Remove beginning of audio and add new chunk to end byte_data = byte_data[len(chunk):] + chunk buffers_since_check += 1.0 self.wake_word_recognizer.update(chunk) if buffers_since_check > buffers_per_check: buffers_since_check -= buffers_per_check chopped = byte_data[-test_size:] \ if test_size < len(byte_data) else byte_data audio_data = chopped + silence said_wake_word = \ self.wake_word_recognizer.found_wake_word(audio_data) if said_wake_word: payload = { 'hotword': self.wake_word_recognizer.key_phrase, 'start_listening': True, 'sound': self.config.get('sounds', {}).get('start_listening'), "engine": self.wake_word_recognizer.module } emitter.emit("recognizer_loop:hotword", payload) # If enabled, play a wave file with a short sound # to audibly indicate recording has begun. if self.config.get('confirm_listening'): file = self.config.get('sounds', {}).get('start_listening') if file: play_wav(file) # if a wake word is success full then record audio in temp # file. if self.save_wake_words: audio = self._create_audio_data(byte_data, source) if not isdir(self.save_wake_words_dir): mkdir(self.save_wake_words_dir) dr = self.save_wake_words_dir components = [ self.wake_word_name.replace(' ', '-'), md5(ww_module.encode('utf-8')).hexdigest(), str(int(1000 * get_time())), model_hash ] fn = join(dr, '.'.join(components) + '.wav') with open(fn, 'wb') as f: f.write(audio.get_wav_data()) else: said_wake_word, said_hot_word = self.check_for_hotwords( audio_data, emitter) if said_hot_word: # reset bytearray to store audio in, else many # serial detections byte_data = silence
def __init__(self, image_location, behaviour="SACCADE", fps=90, resolution=128, image_on_time_ms=1000, inter_off_time_ms=100, max_saccade_distance=1, frames_per_microsaccade=1, frames_per_saccade=29, start_img_idx=0, max_num_images=60000, max_cycles=3, fade_with_mask=True, background_gray=0): self.max_cycles = max_cycles self.num_cycles = 0 self.max_num_images = max_num_images self.start_img_idx = start_img_idx self.total_images = 0 self.image_filenames = self.get_images_paths(image_location) self.fps = fps self.time_period = 1. / fps self.half_frame = int((fps * (image_on_time_ms / 1000.)) / 2.) self.image_on_time = image_on_time_ms / 1000. self.inter_off_time = inter_off_time_ms / 1000. self.max_saccade_distance = max_saccade_distance self.traverse_speed = (resolution * 2.) // (self.image_on_time * self.fps) self.frames_per_microsaccade = frames_per_microsaccade self.frames_per_saccade = frames_per_saccade self.background_gray = background_gray self.center_x = 0 self.center_y = 0 self.img_smaller = False self.img_height = 0 #original resolution self.img_width = 0 self.from_col = 0 self.to_col = 0 self.from_row = 0 self.to_row = 0 self.width = resolution #target resolution self.height = resolution self.shape = (self.height, self.width) self.scaled_width = 0 self.behaviour = behaviour self.first_run = True self.running = True self.locked = False self.gray_image = None self.tmp_image = None self.tmp_orig = np.zeros(self.shape, dtype=DTYPE) self.original_image = np.zeros(self.shape, dtype=DTYPE) self.current_image = np.zeros(self.shape, dtype=DTYPE) self.current_image_idx = 0 self.global_image_idx = 0 self.frame_prev_time = get_time() self.frame_number = 0 self.current_buffer = 0 self.buffer_size = 20 self.half_buffer_size = self.buffer_size // 2 self.all_in_buffer = self.total_images <= self.buffer_size self.image_buffer = [[], []] if self.all_in_buffer: self.buffer_size = self.total_images for _ in range(self.buffer_size): self.image_buffer[self.current_buffer].append( np.zeros(self.shape, dtype=DTYPE)) else: for _ in range(self.buffer_size): self.image_buffer[self.current_buffer].append( np.zeros(self.shape, dtype=DTYPE)) self.image_buffer[int(not self.current_buffer)].append( \ np.zeros(self.shape, dtype=DTYPE) ) self.buffer_start_idx = 0 self.load_images(self.current_buffer, self.global_image_idx, self.current_image_idx) self.current_image[:] = self.image_buffer[self.current_buffer][0] self.fade_with_mask = fade_with_mask if fade_with_mask: to_per_unit = 1. / 255. dirname = os.path.dirname( os.path.abspath(inspect.getfile(inspect.currentframe()))) f = os.path.join(dirname, "fading_mask.png") self.fade_mask = cv2.imread(f, cv2.IMREAD_GRAYSCALE) * to_per_unit if self.behaviour == VirtualCam.BEHAVE_FADE or \ self.behaviour == VirtualCam.BEHAVE_TRAVERSE: self.current_image[:] = self.background_gray if not self.all_in_buffer: self.double_buffer_thread = Thread( name="buffering", target=self.handle_double_buffering) self.double_buffer_thread.start() self.on_off_start_time = get_time() self.showing_img = True
def read(self, ref): image_on_time = self.image_on_time inter_off_time = self.inter_off_time background = self.background_gray behaviour = self.behaviour traverse = VirtualCam.BEHAVE_TRAVERSE fade = VirtualCam.BEHAVE_FADE num_images = self.total_images all_in_buffer = self.all_in_buffer buffer_size = self.buffer_size start = get_time() run_time = start - self.on_off_start_time if behaviour == VirtualCam.BEHAVE_NONE: self.current_image = self.image_buffer[self.current_buffer]\ [self.current_image_idx] self.current_image_idx += 1 self.global_image_idx += 1 if self.global_image_idx == num_images: self.current_image_idx = 0 self.global_image_idx = 0 if not all_in_buffer: self.current_buffer = int(not self.current_buffer) elif self.current_image_idx == buffer_size: self.current_image_idx = 0 if not all_in_buffer: self.current_buffer = int(not self.current_buffer) else: if self.num_cycles == self.max_cycles: self.current_image[:] = background self.original_image[:] = background return False, self.current_image if not self.showing_img: if run_time >= inter_off_time: self.showing_img = True self.on_off_start_time = get_time() # self.current_image[:] = self.image_buffer[self.current_buffer][self.current_image_idx] # self.original_image[:] = self.current_image # print("buffer %s, index %s, frame %s, global idx %s"%\ # (self.current_buffer, self.current_image_idx, self.frame_number, # self.global_image_idx)) self.current_image_idx += 1 self.global_image_idx += 1 if self.global_image_idx == num_images: self.num_cycles += 1 if self.num_cycles == self.max_cycles: self.current_image[:] = background self.original_image[:] = background return False, self.current_image self.current_image_idx = 0 self.global_image_idx = 0 if not all_in_buffer: self.current_buffer = int(not self.current_buffer) elif self.current_image_idx == buffer_size: self.current_image_idx = 0 if not all_in_buffer: self.current_buffer = int(not self.current_buffer) self.frame_number = 0 self.original_image[:] = self.image_buffer[ self.current_buffer][self.current_image_idx] self.current_image[:] = self.original_image if behaviour == traverse or behaviour == fade: self.current_image[:] = background else: self.center_x = 0 self.center_y = 0 else: self.current_image[:] = background else: if run_time >= image_on_time: self.showing_img = False self.on_off_start_time = get_time() self.frame_number = 0 else: self.move_image(ref) if self.fade_with_mask: self.current_image[:] = gs.mask_image( self.current_image, self.fade_mask) self.frame_number += 1 self.prev_time = get_time() return True, self.current_image