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 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 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
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
