def before_request():
"""Save time before each request"""
timestamp = strftime('[%Y-%b-%d %H:%M]')
g.request_start_time = time.time()
content_size = request.content_length
if content_size and content_size > (15 * 1000000):
logger.error(
f'large content size: {request.content_length / 1000000} MB')
logger.debug(f'time: {timestamp} uri: {request.full_path}')
def turn_randomly(redis_client: Redis):
logger.debug("TODO: implement turn_randomly")
message = json.dumps({
"command": "turn_left",
"speed": 1.0
})
redis_client.publish("subsystem.motor.command", message)
logger.debug("TODO: use compass to know when to stop")
time.sleep(2)
stop_motors(redis_client)
time.sleep(1)
def set_disk_preferences(computer_uuid: str) -> Any:
preferences_key = DiskPreferencesIndex.get(computer_uuid)
if not preferences_key:
return format_rv({})
dp = preferences_key.load()
dp.update_preferences(request.json)
logger.debug(f'update disk preferences: {dp.key}')
return format_rv({'errors': dp.errors})
def set_memory_preferences(computer_uuid: str) -> Any:
preferences_key = MemoryPreferencesIndex.get(computer_uuid)
if not preferences_key:
return format_rv({})
mp = preferences_key.load()
mp.update_preferences(request.json)
logger.debug(f'update memory preferences: {mp.key}')
return format_rv({'errors': mp.errors})
def set_modules_preferences(run_uuid: str) -> Any:
preferences_key = OutputsPreferencesIndex.get(run_uuid)
if not preferences_key:
return format_rv({})
op = preferences_key.load()
op.update_preferences(request.json)
logger.debug(f'update outputs preferences: {op.key}')
return format_rv({'errors': op.errors})
def set_cpu_preferences(computer_uuid: str) -> Any:
preferences_key = CPUPreferencesIndex.get(computer_uuid)
if not preferences_key:
return jsonify({})
cp = preferences_key.load()
cp.update_preferences(request.json)
logger.debug(f'update cpu preferences: {cp.key}')
return jsonify({'errors': cp.errors})
def set_grads_preferences(run_uuid: str) -> Any:
preferences_key = GradientsPreferencesIndex.get(run_uuid)
if not preferences_key:
return jsonify({})
gp = preferences_key.load()
gp.update_preferences(request.json)
logger.debug(f'update gradients references: {gp.key}')
return jsonify({'errors': gp.errors})
def set_metrics_preferences(run_uuid: str) -> Any:
preferences_key = MetricsPreferencesIndex.get(run_uuid)
if not preferences_key:
return jsonify({})
mp = preferences_key.load()
mp.update_preferences(request.json)
logger.debug(f'update metrics references: {mp.key}')
return jsonify({'errors': mp.errors})
def set_params_preferences(run_uuid: str) -> Any:
preferences_key = ParametersPreferencesIndex.get(run_uuid)
if not preferences_key:
return jsonify({})
pp = preferences_key.load()
pp.update_preferences(request.json)
logger.debug(f'update parameters preferences: {pp.key}')
return jsonify({'errors': pp.errors})
def set_network_preferences(computer_uuid: str) -> Any:
preferences_key = NetworkPreferencesIndex.get(computer_uuid)
if not preferences_key:
return jsonify({})
np = preferences_key.load()
np.update_preferences(request.json)
logger.debug(f'update network preferences: {np.key}')
return jsonify({'errors': np.errors})
def set_times_preferences(run_uuid: str) -> Any:
preferences_key = TimesPreferencesIndex.get(run_uuid)
if not preferences_key:
return jsonify({})
tp = preferences_key.load()
tp.update_preferences(request.json)
logger.debug(f'update times references: {tp.key}')
return jsonify({'errors': tp.errors})
def set_process_preferences(computer_uuid: str) -> Any:
preferences_key = ProcessPreferencesIndex.get(computer_uuid)
if not preferences_key:
return jsonify({})
pp = preferences_key.load()
pp.update_preferences(request.json)
logger.debug(f'update process preferences: {pp.key}')
return jsonify({'errors': pp.errors})
def handle_on_wake(redis_client: Redis, pubsub: PubSub, wake_word: str):
while cycle([True]):
command_string = wait_for_wake_word(redis_client, pubsub, wake_word)
if not command_string:
logger.debug("No command received with wake word")
turn_on_led(redis_client, "red")
prompt(redis_client)
try:
logger.debug("Listening for a command")
command_string = get_phrase(redis_client, pubsub, 10)
logger.debug(f"got command string: '{command_string}'")
except ListeningTimeoutException:
say(redis_client, "you took too long.")
finally:
turn_off_led(redis_client, "red")
if not command_string:
logger.debug("No command received before timeout")
continue
answer_affirmative(redis_client)
handle_command(command_string)
sleep(0.01)
def get_phrase(redis_client: Redis, pubsub: PubSub, timeout: int = 0) -> str:
start = time()
request_id = str(uuid1())
redis_client.publish("subsystem.listener.command",
dumps({
"mode": "phrase",
"request_id": request_id
}))
logger.debug(f"Listening for phrase (request_id={request_id})")
while cycle([True]):
waited_so_far = time() - start
if timeout and waited_so_far > timeout:
raise ListeningTimeoutException(
f"Timed out waiting for phrase after {waited_so_far} seconds")
if redis_message := pubsub.get_message():
message = loads(redis_message['data'])
if message['request_id'] != request_id:
logger.debug(f"ignoring request id #{message['request_id']}")
continue
logger.debug(
f"Received a response to request_id #{message['request_id']}")
logger.debug(f"Received phrase was {message['transcription']}")
return message['transcription']
sleep(0.01)
def main():
environment: str = os.getenv("ENVIRONMENT", "dev")
config: Dict = load_config(environment)
initialize_logger(level=config['logging']['level'],
filename=config['logging']['filename'])
redis_host = config['redis']['host']
redis_port = config['redis']['port']
logger.debug(f"Connecting to redis at {redis_host}:{redis_port}")
redis_client: Redis = Redis(host=redis_host, port=redis_port, db=0)
pubsub: PubSub = redis_client.pubsub(ignore_subscribe_messages=True)
try:
pubsub.subscribe("subsystem.listener.recording",
ignore_subscribe_messages=True)
handle_on_wake(redis_client, pubsub, config['wake_word'])
except Exception as e:
logger.exception(f"Something bad happened: {str(e)}")
finally:
logger.debug("Cleaning up")
pubsub.close()
redis_client.close()
logger.debug("Shutting down")
def main():
environment: str = os.getenv("ENVIRONMENT", "dev")
config: Dict = load_config(environment)
initialize_logger(level=config['logging']['level'], filename=config['logging']['filename'])
redis_host = config['redis']['host']
redis_port = config['redis']['port']
logger.debug(f"Connecting to redis at {redis_host}:{redis_port}")
redis_client: Redis = Redis(
host=redis_host, port=redis_port, db=0
)
pubsub: PubSub = redis_client.pubsub(ignore_subscribe_messages=True)
try:
say(redis_client, "here we go!")
drive(redis_client)
while cycle([True]):
logger.debug("Reading distance")
distance = get_distance(pubsub)
logger.debug(f"Distance is {distance}")
if distance < 40.0:
logger.debug("Too close to an obstacle. Turning away.")
stop_motors(redis_client)
say(redis_client, "Can't go that way!")
turn_randomly(redis_client)
drive(redis_client)
sleep(0.01)
except Exception as e:
logger.exception(f"Something bad happened: {str(e)}")
finally:
logger.debug("Cleaning up")
stop_motors(redis_client)
pubsub.close()
redis_client.close()
logger.debug("Shutting down")
def before_request():
"""Save time before each request"""
timestamp = strftime('[%Y-%b-%d %H:%M]')
g.request_start_time = time.time()
logger.debug(f'time: {timestamp} uri: {request.full_path}')
def wait_for_wake_word(redis_client: Redis, pubsub: PubSub,
wake_word: str) -> str:
logger.debug(f"Listening for wake word '{wake_word}'")
phrase = get_phrase(redis_client, pubsub)
while not (m := re.match(rf"{wake_word}\b(.*)", phrase, re.I)):
phrase = get_phrase(redis_client, pubsub)
def handle_command(command: str):
logger.debug(f"TODO: handle command: '{command}'")
def say(redis_client: Redis, phrase: str):
logger.debug(f"Saying '{phrase}'")
redis_client.publish("subsystem.speech.command", phrase)
