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)