How I Used Nova-Act to find the Best Hotel Deals for AWS re:Invent 2025

- Operating System: Ubuntu or macOS
- Python 3.10 or above

sudo apt update -y && sudo apt install -y python3-pip python3-venv
python3 -m venv myenv
source myenv/bin/activate
pip install nova-act
playwright install chrome

export NOVA_ACT_API_KEY=  

export NOVA_ACT_SKIP_PLAYWRIGHT_INSTALL=1 

python -m my_nova_act_hotels --headless --checkin "2025-11-30" --checkout "2025-12-04" --destination "CAESARS FORUM Convention Center, Las Vegas" 

#!/usr/bin/env python3
"""
This script uses Nova Act to:
  1. Search Vegas.com for hotels for given check-in and check-out dates (1 room, 1 traveler).
  2. From the Vegas.com results, selects the first 10 hotels.
  3. For each hotel, checks the walking distance from the specified destination.
  4. Prepares a sorted table of hotels by walking distance and price.

Usage:
    python -m my_nova_act_hotels --headless True --checkin "2025-11-30" --checkout "2025-12-04" --destination "CAESARS FORUM Convention Center, Las Vegas"
"""

import fire  # type: ignore
from concurrent.futures import ThreadPoolExecutor, as_completed
import pandas as pd
from pydantic import BaseModel
from nova_act import NovaAct, ActError, BOOL_SCHEMA

# ----- Pydantic Models ----- #

class VegasHotel(BaseModel):
    name: str
    price: float

class VegasHotelList(BaseModel):
    hotels: list[VegasHotel]

class WalkingInfo(BaseModel):
    walking_distance_miles: float
    walking_time_minutes: int

# ----- Vegas.com Search Functions ----- #

def search_vegas(headless: bool, checkin: str, checkout: str, max_retries: int = 1) -> list[VegasHotel]:
    """
    Perform a Vegas.com search for hotels with the specified check-in/out, returns at least 10 hotel results if available; 
    if not, returns whatever is visible.
    """
    for attempt in range(max_retries):
        try:
            with NovaAct(starting_page="https://www.vegas.com/hotels/", headless=headless) as nova:
                result = nova.act(
                    "Is there a cookie banner, email signup, or promotion visible?",
                    schema=BOOL_SCHEMA
                )
                #if result.matches_schema and result.parsed_response:
                #    nova.act("Click 'No Thanks' or close promotional offers")

                nova.act(f"select check-in date to {checkin}.")
                nova.act(f"select check-out date to {checkout}.")
                #nova.act("Set travelers to 1 room, 1 adult")
                nova.act("Click the 'Search' button.")

                result = nova.act(
                    "Are hotel results visible with prices?",
                    schema=BOOL_SCHEMA
                )
                if not result.parsed_response:
                    continue

                #nova.act("Filter hotels by Location 'Strip'")

                hotels = []
                for scroll_attempt in range(5):
                    result = nova.act(
                        "Return the visible hotels",
                        schema=VegasHotelList.model_json_schema()
                    )
                    if result.matches_schema:
                        validated = VegasHotelList.model_validate(result.parsed_response)
                        hotels.extend(validated.hotels)
                        print(f"Accumulated {len(hotels)} hotels so far")
                        if len(hotels) >= 10:
                            break
                    # Provide a specific scroll instruction.
                    nova.act("Scroll down once.")# Stop and return if you see 2 or more hotels, or if there are no more hotels")
                nova.act("Stop scrolling; assume we have the hotel results.")
                return hotels[:10]  # Return up to 10 hotels.
        except ActError as e:
            print(f"Search attempt {attempt + 1} failed: {str(e)}")
    return hotels if hotels else []

# ----- Google Maps Walking Analysis ----- #

def get_walking_info(hotel: VegasHotel, headless: bool, destination: str) ->  WalkingInfo | None:
    """
    Uses Google Maps to get the walking distance and time to the specified destination
    from the hotel's address (assumed to be identifiable by its name).
    Returns a WalkingInfo object if successful, otherwise None.
    """

    with NovaAct(starting_page="https://maps.google.com/", headless=headless) as nova:
            #nova.act("Search for 'CAESARS FORUM Convention Center, Las Vegas' and press enter.")
            nova.act(f"Enter '{destination}' in the search box and press enter.")
            nova.act("Click Directions.")
            nova.act(f"Enter '{hotel.name}' into the starting point field and press enter.")
            nova.act("Click on the walking icon to select walking directions.")
            result = nova.act(
                "Return the walking distance and walking time.",
                schema=WalkingInfo.model_json_schema()
            )
            if not result.matches_schema:
                print(f"Invalid JSON {result=}")
                return None
            walking_distance_miles = WalkingInfo.model_validate(result.parsed_response)
            return walking_distance_miles

# ----- Main Workflow ----- #

def main(headless: bool = False, checkin: str = "2025-11-30", checkout: str = "2025-12-04", destination: str = "CAESARS FORUM Convention Center, Las Vegas"):
    try:
        print("\n=== Vegas.com Hotel Search ===")
        hotels = search_vegas(headless, checkin, checkout)
        if not hotels:
            print("No hotels found")
            return 

        print("Vegas.com search complete. Found hotels:")

        hotels = list({hotel.name: hotel for hotel in hotels}.values())

        for hotel in hotels:
            print(f"  - {hotel.name} at ${hotel.price:.2f}")
        print("\n=== Walking Distance Analysis ===")
        results = []
        with ThreadPoolExecutor() as executor:
            futures = {executor.submit(get_walking_info, h, headless, destination=destination): h for h in hotels}
            for future in as_completed(futures):
                hotel = futures[future]
                try:
                    walking = future.result()
                    if walking is not None:
                        results.append(hotel.model_dump() | walking.model_dump())
                    else:
                        results.append(hotel.model_dump())
                    print(f"Processed {hotel.name}")
                except Exception as e:  # Add exception handling per future
                    print(f"Failed to process {hotel}: {str(e)}")
                    results.append(hotel.model_dump())
        df = pd.DataFrame(results)
        # First check if walking_distance_miles exists in the dataframe
        if "walking_distance_miles" in df.columns:
            # If exists, sort by both distance and price
            df["Sort Distance"] = pd.to_numeric(df["walking_distance_miles"], errors="coerce")
            df["Sort Price"] = df["price"]
            sorted_df = df.sort_values([ "Sort Distance","Sort Price"])
        else:
            # If no distance field, sort by price only
            df["Sort Price"] = df["price"]
            sorted_df = df.sort_values("Sort Price")
        # Drop the temporary sorting columns if they exist
        columns_to_drop = [col for col in ["Sort Distance", "Sort Price"] if col in sorted_df.columns]
        sorted_df = sorted_df.drop(columns=columns_to_drop)
        print("\n=== Final Results ===")
        print(sorted_df.to_string(index=False))

    except Exception as e:
        print(e)

if __name__ == "__main__":
    fire.Fire(main)                                                

=== Final Results ===
                                name  price  walking_distance_miles  walking_time_minutes
                            Flamingo  123.0                     0.5                    10
                           Excalibur   50.0                     0.6                    12
     THE STRAT HOTEL, CASINO & TOWER   61.0                     0.6                    12
             Fontainebleau Las Vegas  184.0                     1.7                    39
WESTGATE LAS VEGAS RESORT AND CASINO  124.0                     1.8                    42
                    Sahara Las Vegas  125.0                     2.1                    47
                        Mandalay Bay  573.0                     2.3                    53
                               Luxor   87.0                     2.4                    52
   Cirque Hotel, Casino & Theme Park   50.0                     4.2                    96