from hopx import Sandbox

# Create sandbox with desktop capabilities

sandbox = Sandbox.create(template="desktop")

# Verify browser installation

result = sandbox.commands.run("chromium --version")

print(result.stdout)  # Chromium 120.0.6099.71

from hopx import Sandbox

sandbox = Sandbox.create(template="desktop")

# Write Playwright script

playwright_script = '''

import asyncio

from playwright.async_api import async_playwright

async def main():

    async with async_playwright() as p:

        browser = await p.chromium.launch(headless=True)

        page = await browser.new_page()

        # Navigate and take screenshot

        await page.goto('https://hopx.ai')

        await page.screenshot(path='/tmp/homepage.png')

        # Get page title

        title = await page.title()

        print(f"Page title: {title}")

        await browser.close()

asyncio.run(main())

'''

sandbox.files.write("/app/scrape.py", playwright_script)

result = sandbox.commands.run("cd /app && python scrape.py")

print(result.stdout)

# Download the screenshot

screenshot = sandbox.files.read("/tmp/homepage.png")

with open("homepage.png", "wb") as f:

    f.write(screenshot)

from hopx import Sandbox

sandbox = Sandbox.create(template="desktop")

form_script = '''

import asyncio

from playwright.async_api import async_playwright

async def main():

    async with async_playwright() as p:

        browser = await p.chromium.launch(headless=True)

        page = await browser.new_page()

        # Navigate to a form

        await page.goto('https://example.com/contact')

        # Fill form fields

        await page.fill('#name', 'John Doe')

        await page.fill('#email', 'john@example.com')

        await page.fill('#message', 'Hello from HopX!')

        # Submit and wait for response

        await page.click('button[type="submit"]')

        await page.wait_for_selector('.success-message')

        # Extract confirmation

        confirmation = await page.text_content('.success-message')

        print(f"Result: {confirmation}")

        await browser.close()

asyncio.run(main())

'''

sandbox.files.write("/app/form.py", form_script)

result = sandbox.commands.run("cd /app && python form.py")

print(result.stdout)

from hopx import Sandbox

import concurrent.futures

def scrape_url(url):

    """Scrape a single URL in its own sandbox"""

    sandbox = Sandbox.create(template="desktop")

    script = f'''

import asyncio

from playwright.async_api import async_playwright

async def main():

    async with async_playwright() as p:

        browser = await p.chromium.launch(headless=True)

        page = await browser.new_page()

        await page.goto("{url}")

        title = await page.title()

        content = await page.content()

        print(f"Title: {{title}}")

        print(f"Length: {{len(content)}} chars")

        await browser.close()

asyncio.run(main())

'''

    sandbox.files.write("/app/scrape.py", script)

    result = sandbox.commands.run("cd /app && python scrape.py")

    sandbox.kill()  # Clean up

    return result.stdout

# Scrape multiple URLs in parallel

urls = [

    "https://news.ycombinator.com",

    "https://github.com/trending",

    "https://reddit.com/r/programming",

    "https://dev.to",

    "https://lobste.rs"

]

with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:

    results = list(executor.map(scrape_url, urls))

for url, result in zip(urls, results):

    print(f"\n{url}:")

    print(result)

from hopx import Sandbox

sandbox = Sandbox.create(template="desktop")

selenium_script = '''

from selenium import webdriver

from selenium.webdriver.chrome.options import Options

from selenium.webdriver.common.by import By

from selenium.webdriver.support.ui import WebDriverWait

from selenium.webdriver.support import expected_conditions as EC

# Configure headless Chrome

options = Options()

options.add_argument('--headless')

options.add_argument('--no-sandbox')

options.add_argument('--disable-dev-shm-usage')

options.add_argument('--disable-gpu')

driver = webdriver.Chrome(options=options)

try:

    driver.get('https://hopx.ai')

    # Wait for element to load

    wait = WebDriverWait(driver, 10)

    element = wait.until(

        EC.presence_of_element_located((By.TAG_NAME, "h1"))

    )

    print(f"Title: {driver.title}")

    print(f"H1: {element.text}")

    # Take screenshot

    driver.save_screenshot('/tmp/selenium-shot.png')

finally:

    driver.quit()

'''

sandbox.files.write("/app/selenium_test.py", selenium_script)

result = sandbox.commands.run("cd /app && python selenium_test.py")

print(result.stdout)

from hopx import Sandbox

sandbox = Sandbox.create(template="desktop")

rpa_script = '''

import asyncio

from playwright.async_api import async_playwright

import json

async def process_invoices():

    async with async_playwright() as p:

        browser = await p.chromium.launch(headless=True)

        context = await browser.new_context()

        page = await context.new_page()

        # Login to invoice portal

        await page.goto('https://invoices.example.com/login')

        await page.fill('#username', 'automation@company.com')

        await page.fill('#password', 'secure_password')

        await page.click('#login-button')

        # Wait for dashboard

        await page.wait_for_selector('.invoice-list')

        # Get all pending invoices

        invoices = await page.query_selector_all('.invoice-item.pending')

        processed = []

        for invoice in invoices:

            invoice_id = await invoice.get_attribute('data-id')

            amount = await invoice.text_content('.amount')

            # Click to open invoice

            await invoice.click()

            await page.wait_for_selector('.invoice-details')

            # Approve invoice

            await page.click('#approve-button')

            await page.wait_for_selector('.approval-success')

            processed.append({

                'id': invoice_id,

                'amount': amount,

                'status': 'approved'

            })

            # Go back to list

            await page.click('.back-to-list')

            await page.wait_for_selector('.invoice-list')

        print(json.dumps(processed, indent=2))

        await browser.close()

asyncio.run(process_invoices())

'''

sandbox.files.write("/app/rpa_invoices.py", rpa_script)

result = sandbox.commands.run("cd /app && python rpa_invoices.py")

print(result.stdout)

from hopx import Sandbox

import json

# Data to be entered

records = [

    {"name": "Alice Johnson", "email": "alice@example.com", "role": "Developer"},

    {"name": "Bob Smith", "email": "bob@example.com", "role": "Designer"},

    {"name": "Carol White", "email": "carol@example.com", "role": "Manager"},

]

sandbox = Sandbox.create(template="desktop")

rpa_script = '''

import asyncio

from playwright.async_api import async_playwright

import json

async def enter_records(records):

    async with async_playwright() as p:

        browser = await p.chromium.launch(headless=True)

        page = await browser.new_page()

        await page.goto('https://hr-portal.example.com/employees')

        for record in records:

            # Click "Add Employee" button

            await page.click('#add-employee')

            await page.wait_for_selector('#employee-form')

            # Fill form

            await page.fill('#name', record['name'])

            await page.fill('#email', record['email'])

            await page.select_option('#role', record['role'])

            # Submit

            await page.click('#submit-employee')

            await page.wait_for_selector('.success-toast')

            print(f"Added: {record['name']}")

        await browser.close()

records = ''' + json.dumps(records) + '''

asyncio.run(enter_records(records))

'''

sandbox.files.write("/app/data_entry.py", rpa_script)

result = sandbox.commands.run("cd /app && python data_entry.py")

print(result.stdout)

from hopx import Sandbox

sandbox = Sandbox.create(template="desktop")

# Write test file

test_script = '''

import pytest

import asyncio

from playwright.async_api import async_playwright

class TestHomepage:

    @pytest.fixture(scope="class")

    def browser(self):

        async def get_browser():

            p = await async_playwright().start()

            browser = await p.chromium.launch(headless=True)

            yield browser

            await browser.close()

            await p.stop()

        return asyncio.get_event_loop().run_until_complete(get_browser())

    def test_homepage_loads(self, browser):

        async def check():

            page = await browser.new_page()

            response = await page.goto('https://hopx.ai')

            assert response.status == 200

            await page.close()

        asyncio.get_event_loop().run_until_complete(check())

    def test_title_correct(self, browser):

        async def check():

            page = await browser.new_page()

            await page.goto('https://hopx.ai')

            title = await page.title()

            assert 'HopX' in title

            await page.close()

        asyncio.get_event_loop().run_until_complete(check())

    def test_navigation_works(self, browser):

        async def check():

            page = await browser.new_page()

            await page.goto('https://hopx.ai')

            await page.click('a[href="/docs"]')

            await page.wait_for_url('**/docs**')

            assert '/docs' in page.url

            await page.close()

        asyncio.get_event_loop().run_until_complete(check())

'''

sandbox.files.write("/app/test_homepage.py", test_script)

result = sandbox.commands.run("cd /app && pytest test_homepage.py -v")

print(result.stdout)

from hopx import Sandbox

sandbox = Sandbox.create(template="desktop")

auth_script = '''

import asyncio

from playwright.async_api import async_playwright

async def authenticated_session():

    async with async_playwright() as p:

        browser = await p.chromium.launch(headless=True)

        # Create persistent context with storage

        context = await browser.new_context(

            storage_state=None  # Start fresh

        )

        page = await context.new_page()

        # Login

        await page.goto('https://app.example.com/login')

        await page.fill('#email', 'user@example.com')

        await page.fill('#password', 'password123')

        await page.click('#login')

        # Wait for login to complete

        await page.wait_for_url('**/dashboard**')

        # Save authentication state

        await context.storage_state(path='/tmp/auth_state.json')

        print("Authentication state saved!")

        # Now you can reuse this state in future sessions

        await browser.close()

asyncio.run(authenticated_session())

'''

sandbox.files.write("/app/auth.py", auth_script)

result = sandbox.commands.run("cd /app && python auth.py")

print(result.stdout)

# Later, use the saved state

reuse_script = '''

import asyncio

from playwright.async_api import async_playwright

async def reuse_session():

    async with async_playwright() as p:

        browser = await p.chromium.launch(headless=True)

        # Reuse saved authentication

        context = await browser.new_context(

            storage_state='/tmp/auth_state.json'

        )

        page = await context.new_page()

        await page.goto('https://app.example.com/dashboard')

        # Already logged in!

        print(f"Current page: {page.url}")

        await browser.close()

asyncio.run(reuse_session())

'''

sandbox.files.write("/app/reuse.py", reuse_script)

result = sandbox.commands.run("cd /app && python reuse.py")

print(result.stdout)

browser = await p.chromium.launch(

    headless=True,

    args=['--no-sandbox', '--disable-dev-shm-usage']

)

page.set_default_timeout(30000)  # 30 seconds

await page.wait_for_selector('.element', timeout=10000)

try:

    await page.click('#button')

except playwright.TimeoutError:

    print("Button not found, taking screenshot for debugging")

    await page.screenshot(path='/tmp/error.png')

sandbox = Sandbox.create(template="desktop")

try:

    # ... automation code ...

finally:

    sandbox.kill()  # Always clean up

async def retry_click(page, selector, max_retries=3):

    for attempt in range(max_retries):

        try:

            await page.click(selector)

            return True

        except Exception as e:

            if attempt == max_retries - 1:

                raise

            await asyncio.sleep(1)