AI's New Eyes: Forging Digital Perception with DOM Visualizers

# Create a script named `test_scrape.py` or run this in a notebook cell
import asyncio
from pipulate import pip

async def main():
    print("🧪 Scraping a sample page to get a DOM file...")
    # Scrape a simple but non-trivial page
    result = await pip.scrape(url="https://example.com", headless=True)
    if result.get("success"):
        dom_path = result.get("looking_at_files", {}).get("dom")
        if dom_path:
            print(f"✅ Success! DOM file saved to: {dom_path}")
            print("\nNow you can run the visualizer scripts against this file.")
        else:
            print("❌ Scrape succeeded, but DOM path not found in result.")

## Addressing the Last Detail: Notebook Output Path
    else:
        print(f"❌ Scrape failed: {result.get('error')}")

if __name__ == "__main__":
    asyncio.run(main())

# In a Jupyter cell

import asyncio
from pipulate import pip
import nest_asyncio

# Apply the patch to allow nested event loops
nest_asyncio.apply()

async def main():
    """The main async function to run the scrape test."""
    print("🧪 Scraping a sample page to get a DOM file...")
    # Scrape a simple but non-trivial page
    result = await pip.scrape(url="https://example.com", headless=True)
    if result.get("success"):
        dom_path = result.get("looking_at_files", {}).get("dom")
        if dom_path:
            print(f"✅ Success! DOM file saved to: {dom_path}")
            print("\nNow you can run the visualizer scripts against this file.")
        else:
            print("❌ Scrape succeeded, but DOM path not found in result.")
    else:
        print(f"❌ Scrape failed: {result.get('error')}")

# In a notebook, you can use 'await' directly at the top level of a cell
await main()

# /home/mike/repos/pipulate/tools/dom_tools.py
#!/usr/bin/env python3
"""
DOM Visualization Tools

Provides functions to render DOM structures as ASCII art, either as a
hierarchical tree or as nested boxes. These are exposed as auto-discoverable
tools for AI and CLI usage.
"""

import sys
from pathlib import Path
from bs4 import BeautifulSoup
from rich.console import Console
from rich.text import Text
from rich.panel import Panel
from rich.tree import Tree
from rich.box import ROUNDED, DOUBLE, HEAVY, ASCII
import re

# This makes the 'tools' package importable when run as a script
sys.path.insert(0, str(Path(__file__).parent.parent))

from tools import auto_tool

# Note: The classes are kept internal to this module, and the async functions
# below are the public-facing tools.

class _DOMHierarchyVisualizer:
    # ... (All the code from the original DOMHierarchyVisualizer class)
    def __init__(self, console_width=180):
        self.console = Console(record=True, width=console_width)
        self.level_colors = ["bright_red", "bright_green", "bright_yellow", "bright_blue", "bright_magenta", "bright_cyan", "red", "green", "yellow", "blue", "magenta", "cyan", "white"]

    def get_color_for_level(self, level):
        return self.level_colors[level % len(self.level_colors)]

    def extract_element_info(self, element):
        info = {'tag': element.name, 'id': element.get('id'), 'class': element.get('class'), 'aria_label': element.get('aria-label'), 'data_testid': element.get('data-testid'), 'href': element.get('href'), 'src': element.get('src'), 'text': None}
        if element.string:
            text = element.string.strip()
            if text: info['text'] = text[:50] + "..." if len(text) > 50 else text
        return info

    def format_element_display(self, info, level):
        color = self.get_color_for_level(level)
        display_parts = [f"<{info['tag']}>"]
        if info['id']: display_parts.append(f"id='{info['id']}'")
        if info['class']: display_parts.append(f"class='{' '.join(info['class'])}'")
        if info['data_testid']: display_parts.append(f"data-testid='{info['data_testid']}'")
        if info['aria_label']: display_parts.append(f"aria-label='{info['aria_label']}'")
        if info['href']: display_parts.append(f"href='{info['href'][:30]}...'")
        if info['src']: display_parts.append(f"src='{info['src'][:30]}...'")
        if info['text']: display_parts.append(f'"{info["text"]}"')
        return Text(" ".join(display_parts), style=color)

    def build_tree_structure(self, element, tree_node, level=0):
        info = self.extract_element_info(element)
        display_text = self.format_element_display(info, level)
        current_node = tree_node.add(display_text)
        for child in element.children:
            if hasattr(child, 'name') and child.name:
                self.build_tree_structure(child, current_node, level + 1)

    def visualize_dom_content(self, html_content, source_name="DOM"):
        soup = BeautifulSoup(html_content, 'html.parser')
        tree = Tree(Text("🌐 Document Root", style="bold white"), style="dim")
        root_element = soup.find('html') or soup
        if root_element and hasattr(root_element, 'name'):
            self.build_tree_structure(root_element, tree, 0)
        self.console.print(tree)
        return self.console.export_text()

class _DOMBoxVisualizer:
    # ... (All the code from the original DOMBoxVisualizer class)
    def __init__(self, console_width=180):
        self.console = Console(record=True, width=console_width)
        self.level_colors = ["bright_red", "bright_green", "bright_yellow", "bright_blue", "bright_magenta", "bright_cyan", "red", "green", "yellow", "blue", "magenta", "cyan", "white"]
        self.box_styles = [DOUBLE, HEAVY, ROUNDED, ASCII]
        self.max_content_width = int(console_width * 0.9)
        self.max_children_to_show = 8

    def get_color_for_level(self, level):
        return self.level_colors[level % len(self.level_colors)]

    def get_box_style_for_level(self, level):
        return self.box_styles[level % len(self.box_styles)]

    def extract_element_info(self, element):
        info = {'tag': element.name, 'id': element.get('id'), 'class': element.get('class'), 'aria_label': element.get('aria-label'), 'data_testid': element.get('data-testid'), 'href': element.get('href'), 'src': element.get('src'), 'text': None}
        if element.string:
            text = element.string.strip()
            if text: info['text'] = text[:60] + "..." if len(text) > 60 else text
        else:
            texts = []
            for child in element.children:
                if isinstance(child, str):
                    child_text = child.strip()
                    if child_text: texts.append(child_text)
                elif hasattr(child, 'string') and child.string:
                    child_text = child.string.strip()
                    if child_text: texts.append(child_text)
            if texts:
                combined_text = ' '.join(texts)
                info['text'] = combined_text[:60] + "..." if len(combined_text) > 60 else combined_text
        return info

    def format_element_title(self, info, level):
        color = self.get_color_for_level(level)
        title_parts = [f"<{info['tag']}>"]
        if info['id']: title_parts.append(f"#{info['id']}")
        if info['data_testid']: title_parts.append(f"[testid={info['data_testid']}]")
        if info['aria_label']: title_parts.append(f"[aria={info['aria_label'][:15]}...]")
        return Text(" ".join(title_parts), style=f"bold {color}")

    def format_element_content(self, info, children_count, level):
        color = self.get_color_for_level(level)
        content_lines = []
        if info['class']:
            classes = ' '.join(info['class']) if isinstance(info['class'], list) else info['class']
            if len(classes) > 50: classes = classes[:47] + "..."
            content_lines.append(Text(f"class: {classes}", style=f"dim {color}"))
        if info['href']:
            href = info['href'][:45] + "..." if len(info['href']) > 45 else info['href']
            content_lines.append(Text(f"href: {href}", style=f"dim {color}"))
        if info['src']:
            src = info['src'][:45] + "..." if len(info['src']) > 45 else info['src']
            content_lines.append(Text(f"src: {src}", style=f"dim {color}"))
        if info['text']: content_lines.append(Text(f'"{info["text"]}"', style=f"italic {color}"))
        if children_count > 0:
            child_info = f"[{children_count} child element{'s' if children_count != 1 else ''}]"
            if children_count > self.max_children_to_show: child_info += f" (showing first {self.max_children_to_show})"
            content_lines.append(Text(child_info, style=f"dim {color}"))
        return content_lines

    def build_nested_boxes(self, element, level=0, max_depth=6):
        if level > max_depth: return Text("... (max depth reached)", style="dim white")
        info = self.extract_element_info(element)
        child_elements = [child for child in element.children if hasattr(child, 'name') and child.name]
        children_to_show = child_elements[:self.max_children_to_show]
        title = self.format_element_title(info, level)
        content_lines = self.format_element_content(info, len(child_elements), level)
        if children_to_show and level < max_depth:
            child_boxes = [self.build_nested_boxes(child, level + 1, max_depth) for child in children_to_show if child]
            all_content = content_lines + ([Text("")] if content_lines and child_boxes else [])
            for i, child_box in enumerate(child_boxes):
                all_content.append(child_box)
                if i < len(child_boxes) - 1: all_content.append(Text(""))
        else:
            all_content = content_lines
        if not all_content: all_content = [Text("(empty element)", style="dim")]
        
        from rich.console import Group
        panel_content = Group(*all_content) if len(all_content) > 1 or not isinstance(all_content[0], (Text, Panel)) else all_content[0]

        width_reduction = int(self.max_content_width * 0.08 * level)
        min_width = max(int(self.max_content_width * 0.25), 40)
        calculated_width = max(self.max_content_width - width_reduction, min_width)
        
        return Panel(panel_content, title=title, border_style=self.get_color_for_level(level), box=self.get_box_style_for_level(level), padding=(0, 1), width=calculated_width)

    def visualize_dom_content(self, html_content, source_name="DOM"):
        soup = BeautifulSoup(html_content, 'html.parser')
        root_element = soup.find('html') or soup
        if root_element and hasattr(root_element, 'name'):
            max_depth = 6 if len(soup.find_all()) > 100 else 12
            nested_layout = self.build_nested_boxes(root_element, 0, max_depth)
            self.console.print(nested_layout)
        return self.console.export_text()


@auto_tool
async def visualize_dom_hierarchy(params: dict) -> dict:
    """Renders the DOM from a file as a hierarchical tree."""
    file_path = params.get("file_path")
    if not file_path or not os.path.exists(file_path):
        return {"success": False, "error": f"File not found: {file_path}"}
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            html_content = f.read()
        visualizer = _DOMHierarchyVisualizer()
        output = visualizer.visualize_dom_content(html_content, source_name=file_path)
        return {"success": True, "output": output}
    except Exception as e:
        return {"success": False, "error": str(e)}

@auto_tool
async def visualize_dom_boxes(params: dict) -> dict:
    """Renders the DOM from a file as nested boxes."""
    file_path = params.get("file_path")
    if not file_path or not os.path.exists(file_path):
        return {"success": False, "error": f"File not found: {file_path}"}
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            html_content = f.read()
        visualizer = _DOMBoxVisualizer()
        output = visualizer.visualize_dom_content(html_content, source_name=file_path)
        return {"success": True, "output": output}
    except Exception as e:
        return {"success": False, "error": str(e)}

# /home/mike/repos/pipulate/tools/scraper_tools.py
# /home/mike/repos/pipulate/tools/scraper_tools.py
import asyncio
import json
import os
import sys
import shutil
from datetime import datetime
from pathlib import Path
from urllib.parse import quote, urlparse

from loguru import logger
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from seleniumwire import webdriver as wire_webdriver
from webdriver_manager.chrome import ChromeDriverManager

from tools import auto_tool
from . import dom_tools # NEW: Import our new DOM tools

# --- Helper Functions (still here, unchanged) ---

def get_safe_path_component(url: str) -> tuple[str, str]:
    """Converts a URL into filesystem-safe components for directory paths."""
    parsed = urlparse(url)
    domain = parsed.netloc
    path = parsed.path
    if not path or path == '/':
        path_slug = "%2F" # Use encoded slash for root
    else:
        path_slug = quote(path, safe='').replace('/', '_')[:100]

    return domain, path_slug

# --- The Enhanced Browser Automation Tool ---

@auto_tool
async def selenium_automation(params: dict) -> dict:
    """
    Performs an advanced browser automation scrape of a single URL.
    Captures a rich set of artifacts including DOM, source, headers, screenshot,
    and a visual DOM layout as ASCII art.
    """
    url = params.get("url")
    domain = params.get("domain")
    url_path_slug = params.get("url_path_slug")
    take_screenshot = params.get("take_screenshot", False)
    headless = params.get("headless", True)

    if not all([url, domain, url_path_slug is not None]):
        return {"success": False, "error": "URL, domain, and url_path_slug parameters are required."}

    driver = None
    artifacts = {}
    output_dir = Path("browser_cache/looking_at/") / domain / url_path_slug

    try:
        # --- 1. Clear and Set up output directory ---
        if output_dir.exists():
            logger.info(f"🗑️ Clearing existing artifacts in: {output_dir}")
            shutil.rmtree(output_dir)
        output_dir.mkdir(parents=True, exist_ok=True)
        logger.info(f"💾 Saving new artifacts to: {output_dir}")

        # --- 2. Configure Selenium WebDriver ---
        chrome_options = Options()
        if headless:
            chrome_options.add_argument("--headless")
        chrome_options.add_argument("--no-sandbox")
        chrome_options.add_argument("--disable-dev-shm-usage")
        chrome_options.add_argument("--start-maximized")
        chrome_options.add_argument("--window-size=1920,1080")

        effective_os = os.environ.get('EFFECTIVE_OS', sys.platform)
        service = Service(ChromeDriverManager().install()) if effective_os == 'darwin' else Service()

        logger.info(f"🚀 Initializing Chrome driver (Headless: {headless})...")
        driver = wire_webdriver.Chrome(service=service, options=chrome_options)

        # --- 3. Scrape the Page ---
        logger.info(f"Navigating to: {url}")
        driver.get(url)
        await asyncio.sleep(3)

        # --- 4. Capture Core Artifacts ---
        dom_path = output_dir / "rendered_dom.html"
        dom_path.write_text(driver.execute_script("return document.documentElement.outerHTML;"), encoding='utf-8')
        artifacts['rendered_dom'] = str(dom_path)

        source_path = output_dir / "source_html.html"
        source_path.write_text(driver.page_source, encoding='utf-8')
        artifacts['source_html'] = str(source_path)

        main_request = next((r for r in driver.requests if r.response and r.url == url), driver.last_request)
        if main_request and main_request.response:
            headers_path = output_dir / "response_headers.json"
            headers_path.write_text(json.dumps(dict(main_request.response.headers), indent=2))
            artifacts['response_headers'] = str(headers_path)

        if take_screenshot:
            screenshot_path = output_dir / "screenshot.png"
            driver.save_screenshot(str(screenshot_path))
            artifacts['screenshot'] = str(screenshot_path)

        # --- 5. NEW: Generate Visualization Artifact ---
        logger.info(f"🎨 Generating DOM box visualization...")
        viz_result = await dom_tools.visualize_dom_boxes({"file_path": str(dom_path)})
        if viz_result.get("success"):
            viz_path = output_dir / "dom_layout_boxes.txt"
            viz_path.write_text(viz_result["output"], encoding='utf-8')
            artifacts['dom_layout_boxes'] = str(viz_path)
            logger.success("✅ DOM visualization saved.")
        else:
            logger.warning(f"⚠️ Could not generate DOM visualization: {viz_result.get('error')}")


        logger.success(f"✅ Scrape successful for {url}")
        return {"success": True, "looking_at_files": artifacts}

    except Exception as e:
        logger.error(f"❌ Scrape failed for {url}: {e}", exc_info=True)
        return {"success": False, "error": str(e), "looking_at_files": artifacts}

    finally:
        if driver:
            driver.quit()
            logger.info("Browser closed.")

# patch.py
patches = [
    {
        "file": "pipulate/core.py",
        "block_name": "pipulate_init",
        "new_code": """
    def __init__(self, pipeline_table=None, db=None, friendly_names=None, append_func=None, get_profile_id_func=None, get_profile_name_func=None, model=None, chat_instance=None, db_path=None):
        self.chat = chat_instance
        self.friendly_names = friendly_names
        self.append_to_conversation = append_func
        self.get_current_profile_id = get_profile_id_func
        self.get_profile_name = get_profile_name_func
        self.model = model
        self.message_queue = self.OrderedMessageQueue()
        self.is_notebook_context = bool(db_path) # Flag for notebook context
        
        if db_path:
            # Standalone/Notebook Context: Create our "Parallel Universe" DB using fastlite directly
            from fastlite import Database
            from loguru import logger
            logger.info(f"Pipulate initializing in standalone mode with db: {db_path}")
        
            # 1. Create a database connection using fastlite.Database
            db_conn = Database(db_path)
        
            # 2. Access the table handles via the .t property
            l_store = db_conn.t.store
            l_pipeline = db_conn.t.pipeline
            # Note: We don't need to explicitly create tables; fastlite handles it.
        
            self.pipeline_table = l_pipeline
            # The second argument `Store` from fast_app isn't needed by DictLikeDB.
            self.db = DictLikeDB(l_store, None)
        
            # In standalone mode, some features that rely on the server are stubbed out
            if self.append_to_conversation is None: self.append_to_conversation = lambda msg, role: print(f"[{role}] {msg}")
            if self.get_current_profile_id is None: self.get_current_profile_id = lambda: 'standalone'
            if self.get_profile_name is None: self.get_profile_name = lambda: 'standalone'
        
        else:
            # Server Context: Use the objects passed in from server.py
            from loguru import logger
            logger.info("Pipulate initializing in server mode.")
            self.pipeline_table = pipeline_table
            self.db = db
"""
    },
    {
        "file": "pipulate/core.py",
        "block_name": "scrape_method",
        "new_code": """
    async def scrape(self, url: str, take_screenshot: bool = False, mode: str = 'selenium', headless: bool = True, **kwargs):
        \"\"\"
        Gives AI "eyes" by performing browser automation or HTTP requests to scrape a URL.
        
        This method is the primary entrypoint for scraping and supports multiple modes.
        The default mode is 'selenium' which uses a full browser.
        
        Args:
            url (str): The URL to scrape.
            take_screenshot (bool): Whether to capture a screenshot (selenium mode only). Defaults to False.
            mode (str): The scraping mode to use ('selenium', 'requests', etc.). Defaults to 'selenium'.
            headless (bool): Whether to run the browser in headless mode (selenium mode only). Defaults to True.
            **kwargs: Additional parameters to pass to the underlying automation tool.
        
        Returns:
            dict: The result from the scraper tool, including paths to captured artifacts.
        \"\"\"
        from tools.scraper_tools import selenium_automation
        from urllib.parse import urlparse, quote
        from datetime import datetime
        
        logger.info(f"👁️‍🗨️ Initiating scrape for: {url} (Mode: {mode}, Headless: {headless})")
        
        # --- New Directory Logic ---
        parsed_url = urlparse(url)
        domain = parsed_url.netloc
        path = parsed_url.path or '/'
        # Use quote with an empty safe string to encode everything, including slashes
        url_path_slug = quote(path, safe='')
        
        params = {
            "url": url,
            "domain": domain,
            "url_path_slug": url_path_slug,
            "take_screenshot": take_screenshot,
            "headless": headless,
            "is_notebook_context": self.is_notebook_context, # Pass the context flag
            **kwargs # Pass through any other params
        }
        
        if mode == 'selenium':
            try:
                result = await selenium_automation(params)
                return result
            except Exception as e:
                logger.error(f"❌ Advanced scrape failed for {url}: {e}")
                return {"success": False, "error": str(e)}
        else:
            logger.warning(f"Scrape mode '{mode}' is not yet implemented.")
            return {"success": False, "error": f"Mode '{mode}' not implemented."}
"""
    }
]

# /home/mike/repos/pipulate/tools/scraper_tools.py
# /home/mike/repos/pipulate/tools/scraper_tools.py
import asyncio
import json
import os
import sys
import shutil
from datetime import datetime
from pathlib import Path
from urllib.parse import quote, urlparse

from loguru import logger
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from seleniumwire import webdriver as wire_webdriver
from webdriver_manager.chrome import ChromeDriverManager

from tools import auto_tool
from . import dom_tools

def get_safe_path_component(url: str) -> tuple[str, str]:
    """Converts a URL into filesystem-safe components for directory paths."""
    parsed = urlparse(url)
    domain = parsed.netloc
    path = parsed.path
    if not path or path == '/':
        path_slug = "%2F"
    else:
        path_slug = quote(path, safe='').replace('/', '_')[:100]
    return domain, path_slug

@auto_tool
async def selenium_automation(params: dict) -> dict:
    """
    Performs an advanced browser automation scrape of a single URL.
    Captures a rich set of artifacts including DOM, source, headers, screenshot,
    and a visual DOM layout as ASCII art.
    """
    url = params.get("url")
    domain = params.get("domain")
    url_path_slug = params.get("url_path_slug")
    take_screenshot = params.get("take_screenshot", False)
    headless = params.get("headless", True)
    is_notebook_context = params.get("is_notebook_context", False) # NEW: Get context flag

    if not all([url, domain, url_path_slug is not None]):
        return {"success": False, "error": "URL, domain, and url_path_slug parameters are required."}

    driver = None
    artifacts = {}

    # NEW: Conditionally set the base directory
    base_dir = Path("browser_cache/")
    if not is_notebook_context:
        base_dir = base_dir / "looking_at"
    
    output_dir = base_dir / domain / url_path_slug

    try:
        if output_dir.exists():
            logger.info(f"🗑️ Clearing existing artifacts in: {output_dir}")
            shutil.rmtree(output_dir)
        output_dir.mkdir(parents=True, exist_ok=True)
        logger.info(f"💾 Saving new artifacts to: {output_dir}")

        chrome_options = Options()
        if headless:
            chrome_options.add_argument("--headless")
        chrome_options.add_argument("--no-sandbox")
        chrome_options.add_argument("--disable-dev-shm-usage")
        chrome_options.add_argument("--start-maximized")
        chrome_options.add_argument("--window-size=1920,1080")

        effective_os = os.environ.get('EFFECTIVE_OS', sys.platform)
        service = Service(ChromeDriverManager().install()) if effective_os == 'darwin' else Service()

        logger.info(f"🚀 Initializing Chrome driver (Headless: {headless})...")
        driver = wire_webdriver.Chrome(service=service, options=chrome_options)

        logger.info(f"Navigating to: {url}")
        driver.get(url)
        await asyncio.sleep(3)

        dom_path = output_dir / "rendered_dom.html"
        dom_path.write_text(driver.execute_script("return document.documentElement.outerHTML;"), encoding='utf-8')
        artifacts['rendered_dom'] = str(dom_path)

        source_path = output_dir / "source_html.html"
        source_path.write_text(driver.page_source, encoding='utf-8')
        artifacts['source_html'] = str(source_path)

        main_request = next((r for r in driver.requests if r.response and r.url == url), driver.last_request)
        if main_request and main_request.response:
            headers_path = output_dir / "response_headers.json"
            headers_path.write_text(json.dumps(dict(main_request.response.headers), indent=2))
            artifacts['response_headers'] = str(headers_path)

        if take_screenshot:
            screenshot_path = output_dir / "screenshot.png"
            driver.save_screenshot(str(screenshot_path))
            artifacts['screenshot'] = str(screenshot_path)

        logger.info(f"🎨 Generating DOM box visualization...")
        viz_result = await dom_tools.visualize_dom_boxes({"file_path": str(dom_path)})
        if viz_result.get("success"):
            viz_path = output_dir / "dom_layout_boxes.txt"
            viz_path.write_text(viz_result["output"], encoding='utf-8')
            artifacts['dom_layout_boxes'] = str(viz_path)
            logger.success("✅ DOM visualization saved.")
        else:
            logger.warning(f"⚠️ Could not generate DOM visualization: {viz_result.get('error')}")

        logger.success(f"✅ Scrape successful for {url}")
        return {"success": True, "looking_at_files": artifacts}

    except Exception as e:
        logger.error(f"❌ Scrape failed for {url}: {e}", exc_info=True)
        return {"success": False, "error": str(e), "looking_at_files": artifacts}

    finally:
        if driver:
            driver.quit()
            logger.info("Browser closed.")

# In a Jupyter cell

import asyncio
from pipulate import pip
import nest_asyncio

# Apply the patch to allow nested event loops
nest_asyncio.apply()

async def main():
    """The main async function to run the scrape test."""
    print("🧪 Scraping a sample page to get a DOM file...")
    # Scrape a simple but non-trivial page
    result = await pip.scrape(url="https://example.com", headless=True)
    if result.get("success"):
        # --- FIX: Look for "rendered_dom" instead of "dom" ---
        dom_path = result.get("looking_at_files", {}).get("rendered_dom")
        if dom_path:
            print(f"✅ Success! DOM file saved to: {dom_path}")
            print("\nNow you can run the visualizer scripts against this file.")
        else:
            print("❌ Scrape succeeded, but DOM path not found in result.")
    else:
        print(f"❌ Scrape failed: {result.get('error')}")

# In a notebook, you can use 'await' directly at the top level of a cell
await main()