Build a Hands-Free Recipe App with Python

context:
  expressions:
    set_timer:
      - "[set, start] (a) timer for $pv.TwoDigitInteger:duration minutes"
      - timer for $pv.TwoDigitInteger:duration minutes
    check_timer:
      - how much time is left
      - check (the) timer
    stop_timer:
      - "[stop, cancel, end] (the) timer"
    next_step:
      - "@go_to next step"
      - what's (the) next (step)
      - next instruction
    repeat_step:
      - repeat (the) [last, previous] step
      - repeat that
      - again please
    ingredient_info:
      - how much $ingredient:ingredient (do I need)
      - "(show me) how much (of) $ingredient:ingredient (is needed)"

  slots:
    ingredient:
      - salt
      - pepper
      - sugar
      - oil

  macros:
    go_to:
      - go to
      - take me to
      - skip to

pip install pvrhino pvrecorder

# Initialize Rhino
rhino = pvrhino.create(
    access_key=access_key,
    context_path=context_path)

# Initialize recorder
recorder = PvRecorder(
    device_index=device_index,
    frame_length=rhino.frame_length)

recorder.start()
print("Listening for cooking commands... Press Ctrl+C to exit.\n")

while True:
    pcm = recorder.read()

    is_finalized = rhino.process(pcm)
    if is_finalized:
        inference = rhino.get_inference()
        process_inference(inference)
        rhino.reset()

def process_inference(inference):
    """Process and display the voice recognition inference"""
    if inference.is_understood:
        # Display what was understood
        print("{")
        print(f"  intent : '{inference.intent}'")
        print("  slots : {")
        for slot, value in inference.slots.items():
            print(f"    {slot} : '{value}'")
        print("  }")
        print("}\n")
        # integrate these with calls to your app logic
        handle_cooking_action(inference.intent, inference.slots)
    else:
        print("Didn't understand the command.\n")

def handle_cooking_action(intent, slots):
    """Demo: map intents to cooking actions"""

    actions = {
        "set_timer": lambda: print(f"[Demo] Setting timer for {slots.get('duration', 'unknown')} minutes"),
        "check_timer": lambda: print("[Demo] Checking remaining time"),
        "stop_timer": lambda: print("[Demo] Stopping the timer"),
    }

    if intent in actions:
        actions[intent]()  
        # Replace this with the feature your app needs (e.g. start a timer)
        # For example: start_timer(slots['duration'])
    else:
        print("[Demo] Intent not handled")
        # You can add more intents here as your app grows

import os
import sys
import argparse
import pvrhino
from pvrecorder import PvRecorder


def handle_cooking_action(intent, slots):
    """Handle cooking-specific actions based on intent"""
    if intent == "set_timer":
        duration = slots.get("duration", "unknown")
        print(f"Setting timer for {duration} minutes\n")
    elif intent == "check_timer":
        print("Checking remaining time\n")
    elif intent == "stop_timer":
        print("Stopping the timer\n")
    elif intent == "next_step":
        print("Moving to the next step\n")
    elif intent == "repeat_step":
        print("Repeating the last step\n")
    elif intent == "ingredient_info":
        ingredient = slots.get("ingredient", "unknown")
        print(f"Checking how much {ingredient} you need\n")
    else:
        print("Intent not handled in this demo\n")
    # Replace print statements with your app’s logic
    # (e.g. start_timer(duration))


def process_inference(inference):
    """Process and display the voice recognition inference"""
    if inference.is_understood:
        # Display what was understood
        print("{")
        print(f"  intent : '{inference.intent}'")
        print("  slots : {")
        for slot, value in inference.slots.items():
            print(f"    {slot} : '{value}'")
        print("  }")
        print("}\n")

        # Handle the cooking action
        handle_cooking_action(inference.intent, inference.slots)
    else:
        print("Didn't understand the command.\n")


def main():
    # Set up command line argument parser
    parser = argparse.ArgumentParser(
        description="Rhino Speech-to-Intent Demo for Cooking Assistant"
    )
    parser.add_argument(
        "--access_key",
        required=True,
        help="Picovoice access key"
    )
    parser.add_argument(
        "--context_file_path",
        required=True,
        help="Path to the context file (.rhn)"
    )
    parser.add_argument(
        "--audio_device_index",
        type=int,
        default=-1,
        help="Audio device index (default: -1)"
    )

    args = parser.parse_args()

    # Load command line arguments
    access_key = args.access_key
    context_path = args.context_file_path
    device_index = args.audio_device_index

    if not access_key or len(access_key.strip()) == 0:
        print(
            "Error: Please provide ACCESS_KEY"
        )
        sys.exit(1)

    if not os.path.isfile(context_path):
        print(f"Error: Context file not found at {context_path}")
        sys.exit(1)

    rhino = None
    recorder = None

    try:
        # Initialize Rhino
        rhino = pvrhino.create(
            access_key=access_key,
            context_path=context_path
        )

        # Initialize recorder
        recorder = PvRecorder(
            device_index=device_index,
            frame_length=rhino.frame_length
        )

        recorder.start()
        print(
            "Listening for cooking commands... "
            "Press Ctrl+C to exit.\n"
        )

        while True:
            pcm = recorder.read()

            is_finalized = rhino.process(pcm)
            if is_finalized:
                inference = rhino.get_inference()
                process_inference(inference)
                rhino.reset()

    except KeyboardInterrupt:
        print("\nStopping ...")
    finally:
        recorder.stop()
        recorder.delete()
        rhino.delete()


if __name__ == "__main__":
    main()

python voice-cooking-app.py \
    --access_key="${ACCESS_KEY}" \
    --context_file_path="${CONTEXT_FILE_PATH}" \
    --audio_device_index="${AUDIO_DEVICE_INDEX}"