Build a Best Buy Price Tracker with Python & Proxies

import requests
from bs4 import BeautifulSoup
import time

# We might need time.sleep later to be polite


# Target product URL (Example: ASUS ROG Laptop)
TARGET_URL = (
    "https://www.bestbuy.com/site/asus-rog-zephyrus-g14-14-165hz-gaming-laptop-qhd-"
    "amd-ryzen-9-with-16gb-memory-nvidia-geforce-rtx-4060-512gb-ssd-moonlight-white/"
    "6535495.p?skuId=6535495"
)


def fetch_product_price(url):
    # Mimic a real browser visit with a User-Agent header
    headers = {
        "User-Agent": (
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 (KHTML, like Gecko) "
            "Chrome/114.0.0.0 Safari/537.36"
        )
    }

    try:
        page_content = requests.get(url, headers=headers, timeout=15)
        page_content.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
        parsed_html = BeautifulSoup(page_content.content, 'html.parser')

        # --- IMPORTANT ---
        # Finding the price requires inspecting the Best Buy page HTML.
        # The selectors below worked at one time but WILL change.
        # Use your browser's developer tools (right-click -> Inspect) to find the current tag and class for the price.
        price_container = parsed_html.find(
            "div", {"class": "priceView-hero-price priceView-customer-price"}
        )

        if price_container:
            # Often, the visually hidden span has the clean price
            price_span = price_container.find("span", {"aria-hidden": "true"})
            if price_span:
                price_text = price_span.get_text()
                # Clean up the price string (remove $, commas)
                price_numeric = float(price_text.replace("$", "").replace(",", ""))
                return price_numeric
            else:
                print("Could not find the price span within the container.")
                return None
        else:
             print("Could not find the price container element. Best Buy's layout may have changed.")
             return None
    except requests.exceptions.RequestException as e:
        print(f"Error fetching URL {url}: {e}")
        return None
    except Exception as e:
        print(f"An error occurred during parsing: {e}")
        return None


# Let's test it
current_price = fetch_product_price(TARGET_URL)

if current_price:
    print(f"Current price found: ${current_price}")
else:
    print("Failed to retrieve the price.")

# Example using Evomi residential proxy authentication
proxy_user = 'your_evomi_username'
proxy_pass = 'your_evomi_password'
proxy_host = 'rp.evomi.com'
proxy_port_http = 1000
proxy_port_https = 1001

proxies = {
    'http': f'http://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port_http}',
    'https': f'http://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port_https}'  # Note: requests uses http auth even for https proxies here
}

# Modify the get request in the function like this:
# page_content = requests.get(url, headers=headers, proxies=proxies, timeout=20)  # Increased timeout often needed with proxies

import pandas as pd
from datetime import datetime
import os # (Make sure 'import os' is at the top of your script with other imports)

LOG_FILE = 'bestbuy_price_log.csv'

def log_price_data(price, url):
    if price is None: # Don't log if fetching failed
        return
    timestamp = datetime.now()
    new_data = {
        'Timestamp': [timestamp],
        'Price_USD': [price],
        'Product_URL': [url]
    }
    df = pd.DataFrame(new_data)
    try:
        # Append to CSV without writing header if file exists, include header otherwise
        header = False if os.path.exists(LOG_FILE) else True
        df.to_csv(LOG_FILE, mode='a', header=header, index=False)
        # print(f"Data logged: {timestamp}, ${price}, {url}") # Optional: uncomment for verbose logging
    except Exception as e:
        print(f"Error writing to CSV {LOG_FILE}: {e}")

import requests
from bs4 import BeautifulSoup
import pandas as pd
from datetime import datetime
import time
import os # Added for file checking

TARGET_URL = "https://www.bestbuy.com/site/asus-rog-zephyrus-g14-14-165hz-gaming-laptop-qhd-amd-ryzen-9-with-16gb-memory-nvidia-geforce-rtx-4060-512gb-ssd-moonlight-white/6535495.p?skuId=6535495"
LOG_FILE = 'bestbuy_price_log.csv'

# --- Function: fetch_product_price(url) ---
# (Insert the fetch_product_price function code from above here)
# --- End Function: fetch_product_price ---

# --- Function: log_price_data(price, url) ---
# (Insert the log_price_data function code from above here)
# --- End Function: log_price_data ---

# --- Main execution part ---
product_price = fetch_product_price(TARGET_URL)

if product_price is not None:
    log_price_data(product_price, TARGET_URL)
    print(f"Successfully fetched and logged price: ${product_price}")
else:
    print("Could not fetch or log price.")

import smtplib
import ssl  # For secure connection

# --- IMPORTANT SECURITY NOTE ---
# NEVER hardcode credentials directly in your script like below.
# Use environment variables (e.g., via python-dotenv library) or a secure config file.
SENDER_EMAIL = "your.alert.sender@gmail.com"  # Your dedicated Gmail address
SENDER_PASSWORD = "YOUR_GENERATED_APP_PASSWORD"  # The App Password you created
RECIPIENT_EMAIL = "your.personal.email@example.com"  # Where alerts should go

def send_price_alert(current_price, url, alert_threshold):
    if current_price is None or current_price > alert_threshold:
        return  # No alert needed

    subject = "Price Alert: Item Below Threshold!"
    body = f"Good news!\n\nThe price for the item at {url}\nhas dropped to ${current_price:.2f} (Your threshold was ${alert_threshold:.2f}).\n\nCheck it out!"
    message = f"Subject: {subject}\n\n{body}"

    context = ssl.create_default_context()  # Create a secure SSL context
    try:
        print(f"Attempting to send email alert for price ${current_price:.2f}...")
        with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:  # Use SMTP_SSL for port 465
            server.login(SENDER_EMAIL, SENDER_PASSWORD)
            server.sendmail(SENDER_EMAIL, RECIPIENT_EMAIL, message)
            print(f"Email alert sent successfully to {RECIPIENT_EMAIL}!")
    except smtplib.SMTPAuthenticationError:
        print("SMTP Authentication Error: Check sender email/app password.")
    except Exception as e:
        print(f"Failed to send email: {e}")

# Remember to add 'import ssl' at the top of your file.

import schedule
import time
from datetime import datetime # Assuming datetime is used based on the print statement

# --- Define constants and previous functions here ---
# TARGET_URL = "..."
# LOG_FILE = "..."
# SENDER_EMAIL = "..." (loaded securely!)
# SENDER_PASSWORD = "..." (loaded securely!)
# RECIPIENT_EMAIL = "..."
# ALERT_THRESHOLD = 1499.99 # Set your desired price alert level for the example product

# fetch_product_price(url) definition...
# log_price_data(price, url) definition...
# send_price_alert(price, url, threshold) definition...

# --- End definitions ---

def perform_price_check():
    print(f"Running scheduled price check at {datetime.now()}...")
    # Assuming fetch_product_price is defined elsewhere and returns a float or None
    current_price = fetch_product_price(TARGET_URL)

    if current_price is not None:
        # Assuming log_price_data and send_price_alert are defined elsewhere
        log_price_data(current_price, TARGET_URL)
        send_price_alert(current_price, TARGET_URL, ALERT_THRESHOLD)
        print(f"Check complete. Current price: ${current_price:.2f}")
    else:
        print("Price check failed (fetch returned None).")

# Schedule the job: Run once daily at 10:30 AM
schedule.every().day.at("10:30").do(perform_price_check)
# Other options: .hour, .minute.at(":15"), .monday .at("..."), etc.
# schedule.every(6).hours.do(perform_price_check) # Example: run every 6 hours

print("Scheduler started. Waiting for the scheduled job...")

# Initial check immediately upon starting (optional)
# perform_price_check()

# Keep the script running to allow the scheduler to work
while True:
    schedule.run_pending()
    time.sleep(60) # Check every 60 seconds if a scheduled job is due

import os
import smtplib
import ssl
import time
from datetime import datetime

import pandas as pd
import requests
import schedule
from bs4 import BeautifulSoup

# Consider importing dotenv for secure credential loading
# from dotenv import load_dotenv #
# load_dotenv() # Load variables from .env file

# --- Configuration ---
TARGET_URL = "https://www.bestbuy.com/site/asus-rog-zephyrus-g14-14-165hz-gaming-laptop-qhd-amd-ryzen-9-with-16gb-memory-nvidia-geforce-rtx-4060-512gb-ssd-moonlight-white/6535495.p?skuId=6535495"
LOG_FILE = 'bestbuy_price_log.csv'
ALERT_THRESHOLD = 1499.99  # Desired price for alert

# Securely load credentials (Example using environment variables)
# SENDER_EMAIL = os.getenv("GMAIL_SENDER")
# SENDER_PASSWORD = os.getenv("GMAIL_APP_PASSWORD")
# RECIPIENT_EMAIL = os.getenv("ALERT_RECIPIENT")

# Replace with your actual secure loading method or hardcoded values (NOT recommended for production)
SENDER_EMAIL = "your.alert.sender@gmail.com"
SENDER_PASSWORD = "YOUR_GENERATED_APP_PASSWORD"
RECIPIENT_EMAIL = "your.personal.email@example.com"


# --- Function Definitions ---

def fetch_product_price(url):
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"
    }
    # Add proxy settings here if needed:
    # proxies = { ... }
    try:
        # Add 'proxies=proxies' if using them
        page_content = requests.get(url, headers=headers, timeout=15)
        page_content.raise_for_status()
        parsed_html = BeautifulSoup(page_content.content, 'html.parser')

        # --- Find price element (MUST BE CHECKED/UPDATED) ---
        price_container = parsed_html.find("div", {"class": "priceView-hero-price priceView-customer-price"})
        if price_container:
            price_span = price_container.find("span", {"aria-hidden": "true"})
            if price_span:
                price_text = price_span.get_text()
                price_numeric = float(price_text.replace("$", "").replace(",", ""))
                return price_numeric
    # --- (Rest of the function with error handling as shown before) --- # Note: The original snippet's comment here seems incomplete based on the try block structure. Assuming it meant error handling within the except block.
    except Exception as e:
        print(f"Error fetching or parsing price: {e}")
    return None  # Return None if any step fails


def log_price_data(price, url):
    if price is None:
        return
    timestamp = datetime.now()
    new_data = {'Timestamp': [timestamp], 'Price_USD': [price], 'Product_URL': [url]}
    df = pd.DataFrame(new_data)
    try:
        header = not os.path.exists(LOG_FILE)
        df.to_csv(LOG_FILE, mode='a', header=header, index=False)
    except Exception as e:
        print(f"Error writing to CSV: {e}")


def send_price_alert(current_price, url, alert_threshold):
    if current_price is None or current_price > alert_threshold or not SENDER_EMAIL or not SENDER_PASSWORD or not RECIPIENT_EMAIL:
        return  # No alert needed or config missing

    subject = "Price Alert: Item Below Threshold!"
    body = f"Price Drop!\n\nThe item at {url}\nis now ${current_price:.2f} (Threshold: ${alert_threshold:.2f}).\n\nCheck it out!"
    message = f"Subject: {subject}\n\n{body}"
    context = ssl.create_default_context()

    try:
        with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
            server.login(SENDER_EMAIL, SENDER_PASSWORD)
            server.sendmail(SENDER_EMAIL, RECIPIENT_EMAIL, message)
            print(f"Email alert sent for price ${current_price:.2f}!")
    except Exception as e:
        print(f"Failed to send email alert: {e}")


def perform_price_check():
    print(f"[{datetime.now()}] Running scheduled price check...")
    current_price = fetch_product_price(TARGET_URL)
    if current_price is not None:
        log_price_data(current_price, TARGET_URL)
        send_price_alert(current_price, TARGET_URL, ALERT_THRESHOLD)
        print(f"Check complete. Price: ${current_price:.2f}")
    else:
        print("Price check failed.")


# --- Scheduling ---
schedule.every().day.at("10:30").do(perform_price_check)
# schedule.every(1).hour.do(perform_price_check) # Alternative: hourly check

print("Price tracker starting...")
print(f"Tracking: {TARGET_URL}")
print(f"Alert Threshold: ${ALERT_THRESHOLD:.2f}")
print(f"Logging to: {LOG_FILE}")
print(f"Scheduled daily check at: 10:30")

# Optional: Run check once immediately on start
# perform_price_check()

# --- Main Loop ---
while True:
    schedule.run_pending()
    time.sleep(60)