fastled 1.4.8__py3-none-any.whl → 1.4.10__py3-none-any.whl

fastled/__version__.py

@@ -1,6 +1,6 @@
 # IMPORTANT! There's a bug in github which will REJECT any version update
 # that has any other change in the repo. Please bump the version as the
 # ONLY change in a commit, or else the pypi update and the release will fail.
-__version__ = "1.4.8"
+__version__ = "1.4.10"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

fastled/interruptible_http.py

@@ -0,0 +1,148 @@
+"""
+Interruptible HTTP requests that can be cancelled with Ctrl+C.
+
+This module provides cross-platform HTTP request functionality that can be
+interrupted with Ctrl+C by using asyncio cancellation and periodic checks.
+"""
+
+import asyncio
+
+import httpx
+
+
+class InterruptibleHTTPRequest:
+    """A wrapper for making HTTP requests that can be interrupted by Ctrl+C."""
+
+    def __init__(self):
+        self.cancelled = False
+
+    async def _make_request_async(
+        self,
+        url: str,
+        files: dict,
+        headers: dict,
+        transport: httpx.HTTPTransport | None = None,
+        timeout: float = 240,
+        follow_redirects: bool = True,
+    ) -> httpx.Response:
+        """Make an async HTTP request."""
+        # Convert sync transport to async transport if provided
+        async_transport = None
+        if transport is not None:
+            # For IPv4 connections, create async transport with local address
+            async_transport = httpx.AsyncHTTPTransport(local_address="0.0.0.0")
+
+        async with httpx.AsyncClient(
+            transport=async_transport,
+            timeout=timeout,
+        ) as client:
+            response = await client.post(
+                url,
+                follow_redirects=follow_redirects,
+                files=files,
+                headers=headers,
+            )
+            return response
+
+    def make_request_interruptible(
+        self,
+        url: str,
+        files: dict,
+        headers: dict,
+        transport: httpx.HTTPTransport | None = None,
+        timeout: float = 240,
+        follow_redirects: bool = True,
+    ) -> httpx.Response:
+        """Make an HTTP request that can be interrupted by Ctrl+C."""
+        try:
+            # Create a new event loop if we're not in one
+            try:
+                loop = asyncio.get_running_loop()
+                # We're already in an event loop, use run_in_executor
+                return asyncio.run_coroutine_threadsafe(
+                    self._run_with_keyboard_check(
+                        url, files, headers, transport, timeout, follow_redirects
+                    ),
+                    loop,
+                ).result()
+            except RuntimeError:
+                # No running loop, create one
+                return asyncio.run(
+                    self._run_with_keyboard_check(
+                        url, files, headers, transport, timeout, follow_redirects
+                    )
+                )
+        except KeyboardInterrupt:
+            print("\nHTTP request cancelled by user")
+            raise
+
+    async def _run_with_keyboard_check(
+        self,
+        url: str,
+        files: dict,
+        headers: dict,
+        transport: httpx.HTTPTransport | None = None,
+        timeout: float = 240,
+        follow_redirects: bool = True,
+    ) -> httpx.Response:
+        """Run the request with periodic keyboard interrupt checks."""
+        task = asyncio.create_task(
+            self._make_request_async(
+                url, files, headers, transport, timeout, follow_redirects
+            )
+        )
+
+        # Poll for keyboard interrupt while waiting for the request
+        # This approach allows the task to be cancelled when KeyboardInterrupt
+        # is raised in the calling thread
+        while not task.done():
+            try:
+                # Wait for either completion or a short timeout
+                response = await asyncio.wait_for(asyncio.shield(task), timeout=0.1)
+                return response
+            except asyncio.TimeoutError:
+                # Continue waiting - the short timeout allows for more responsive
+                # cancellation when KeyboardInterrupt is raised
+                continue
+            except KeyboardInterrupt:
+                task.cancel()
+                print("\nHTTP request cancelled by user")
+                raise
+
+        return await task
+
+
+def make_interruptible_post_request(
+    url: str,
+    files: dict | None = None,
+    headers: dict | None = None,
+    transport: httpx.HTTPTransport | None = None,
+    timeout: float = 240,
+    follow_redirects: bool = True,
+) -> httpx.Response:
+    """
+    Convenience function to make an interruptible POST request.
+
+    Args:
+        url: The URL to make the request to
+        files: Files to upload (optional)
+        headers: HTTP headers (optional)
+        transport: HTTP transport to use (optional)
+        timeout: Request timeout in seconds
+        follow_redirects: Whether to follow redirects
+
+    Returns:
+        The HTTP response
+
+    Raises:
+        KeyboardInterrupt: If the request was cancelled by Ctrl+C
+    """
+    request_handler = InterruptibleHTTPRequest()
+    return request_handler.make_request_interruptible(
+        url=url,
+        files=files or {},
+        headers=headers or {},
+        transport=transport,
+        timeout=timeout,
+        follow_redirects=follow_redirects,
+    )

fastled/open_browser.py

@@ -6,7 +6,7 @@ import weakref
 from multiprocessing import Process
 from pathlib import Path
 
-from fastled.playwright_browser import open_with_playwright
+from fastled.playwright.playwright_browser import open_with_playwright
 from fastled.server_flask import run_flask_in_thread
 
 # Global reference to keep Playwright browser alive
@@ -128,7 +128,9 @@ def spawn_http_server(
         if should_use_playwright:
             if app:
                 # For --app mode, try to install browsers if needed
-                from fastled.playwright_browser import install_playwright_browsers
+                from fastled.playwright.playwright_browser import (
+                    install_playwright_browsers,
+                )
 
                 install_playwright_browsers()
 
@@ -136,8 +138,13 @@ def spawn_http_server(
             print(
                 "Auto-resize enabled: Browser window will automatically adjust to content size"
             )
+            print(
+                "🔧 C++ DevTools Support extension will be loaded for DWARF debugging"
+            )
             global _playwright_browser_proxy
-            _playwright_browser_proxy = open_with_playwright(url)
+            _playwright_browser_proxy = open_with_playwright(
+                url, enable_extensions=True
+            )
         else:
             print(f"Opening browser to {url}")
             import webbrowser

fastled/playwright/chrome_extension_downloader.py

@@ -0,0 +1,207 @@
+"""
+Chrome extension downloader utility for FastLED WASM compiler.
+
+This module provides functionality to download Chrome extensions from the
+Chrome Web Store and prepare them for use with Playwright browser.
+"""
+
+import os
+import re
+import shutil
+import tempfile
+import warnings
+import zipfile
+from pathlib import Path
+
+import httpx
+
+
+class ChromeExtensionDownloader:
+    """Downloads Chrome extensions from the Chrome Web Store."""
+
+    # Chrome Web Store CRX download URL
+    CRX_URL = "https://clients2.google.com/service/update2/crx?response=redirect&prodversion=114.0&acceptformat=crx2,crx3&x=id%3D{extension_id}%26uc"
+
+    # Modern user agent string
+    USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36"
+
+    def __init__(self, cache_dir: Path | None = None):
+        """Initialize the Chrome extension downloader.
+
+        Args:
+            cache_dir: Directory to store downloaded extensions.
+                      Defaults to ~/.fastled/chrome-extensions
+        """
+        if cache_dir is None:
+            cache_dir = Path.home() / ".fastled" / "chrome-extensions"
+
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        self.headers = {
+            "User-Agent": self.USER_AGENT,
+            "Referer": "https://chrome.google.com",
+        }
+
+    def extract_extension_id(self, url: str) -> str:
+        """Extract extension ID from Chrome Web Store URL.
+
+        Args:
+            url: Chrome Web Store URL
+
+        Returns:
+            Extension ID string
+
+        Raises:
+            ValueError: If URL is not a valid Chrome Web Store URL
+        """
+        # Match new Chrome Web Store URLs (chromewebstore.google.com)
+        new_pattern = r"chromewebstore\.google\.com/detail/[^/]+/([a-z]{32})"
+        match = re.search(new_pattern, url)
+
+        if match:
+            return match.group(1)
+
+        # Match old Chrome Web Store URLs (chrome.google.com/webstore)
+        old_pattern = r"chrome\.google\.com/webstore/detail/[^/]+/([a-z]{32})"
+        match = re.search(old_pattern, url)
+
+        if match:
+            return match.group(1)
+
+        # Try direct extension ID
+        if re.match(r"^[a-z]{32}$", url):
+            return url
+
+        raise ValueError(f"Invalid Chrome Web Store URL or extension ID: {url}")
+
+    def download_crx(self, extension_id: str) -> bytes:
+        """Download CRX file from Chrome Web Store.
+
+        Args:
+            extension_id: Chrome extension ID
+
+        Returns:
+            CRX file content as bytes
+
+        Raises:
+            httpx.RequestError: If download fails
+        """
+        download_url = self.CRX_URL.format(extension_id=extension_id)
+
+        with httpx.Client(follow_redirects=True) as client:
+            response = client.get(download_url, headers=self.headers)
+            response.raise_for_status()
+
+            return response.content
+
+    def extract_crx_to_directory(self, crx_content: bytes, extract_dir: Path) -> None:
+        """Extract CRX file content to a directory.
+
+        CRX files are essentially ZIP files with a header that needs to be removed.
+
+        Args:
+            crx_content: CRX file content as bytes
+            extract_dir: Directory to extract the extension to
+        """
+        # CRX files have a header before the ZIP content
+        # We need to find the ZIP header (starts with 'PK')
+        zip_start = crx_content.find(b"PK\x03\x04")
+        if zip_start == -1:
+            zip_start = crx_content.find(b"PK\x05\x06")  # Empty ZIP
+
+        if zip_start == -1:
+            raise ValueError("Could not find ZIP header in CRX file")
+
+        # Extract the ZIP portion
+        zip_content = crx_content[zip_start:]
+
+        # Create temporary file to extract from
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as temp_zip:
+            temp_zip.write(zip_content)
+            temp_zip_path = temp_zip.name
+
+        try:
+            # Extract the ZIP file
+            extract_dir.mkdir(parents=True, exist_ok=True)
+            with zipfile.ZipFile(temp_zip_path, "r") as zip_ref:
+                zip_ref.extractall(extract_dir)
+        finally:
+            # Clean up temporary file
+            os.unlink(temp_zip_path)
+
+    def get_extension_path(
+        self, url_or_id: str, extension_name: str | None = None
+    ) -> Path:
+        """Download and extract Chrome extension, returning the path to the extracted directory.
+
+        Args:
+            url_or_id: Chrome Web Store URL or extension ID
+            extension_name: Optional name for the extension directory
+
+        Returns:
+            Path to the extracted extension directory
+        """
+        extension_id = self.extract_extension_id(url_or_id)
+
+        if extension_name is None:
+            extension_name = extension_id
+
+        extension_dir = self.cache_dir / extension_name
+
+        # Check if extension is already downloaded and extracted
+        if extension_dir.exists() and (extension_dir / "manifest.json").exists():
+            print(f"✅ Chrome extension already cached: {extension_dir}")
+            return extension_dir
+
+        print(f"🔽 Downloading Chrome extension {extension_id}...")
+
+        try:
+            # Download the CRX file
+            crx_content = self.download_crx(extension_id)
+
+            # Clean up existing directory if it exists
+            if extension_dir.exists():
+                shutil.rmtree(extension_dir)
+
+            # Extract the CRX file
+            self.extract_crx_to_directory(crx_content, extension_dir)
+
+            # Verify extraction worked
+            if not (extension_dir / "manifest.json").exists():
+                raise ValueError("Extension extraction failed - no manifest.json found")
+
+            print(f"✅ Chrome extension downloaded and extracted: {extension_dir}")
+            return extension_dir
+
+        except Exception as e:
+            warnings.warn(f"Failed to download Chrome extension {extension_id}: {e}")
+            if extension_dir.exists():
+                shutil.rmtree(extension_dir)
+            raise
+
+
+def download_cpp_devtools_extension() -> Path | None:
+    """Download the C++ DevTools Support (DWARF) extension.
+
+    Returns:
+        Path to the extracted extension directory, or None if download failed
+    """
+    # C++ DevTools Support (DWARF) extension
+    extension_url = "https://chromewebstore.google.com/detail/cc++-devtools-support-dwa/pdcpmagijalfljmkmjngeonclgbbannb"
+
+    try:
+        downloader = ChromeExtensionDownloader()
+        return downloader.get_extension_path(extension_url, "cpp-devtools-support")
+    except Exception as e:
+        warnings.warn(f"Failed to download C++ DevTools Support extension: {e}")
+        return None
+
+
+if __name__ == "__main__":
+    # Test the downloader with the C++ DevTools Support extension
+    extension_path = download_cpp_devtools_extension()
+    if extension_path:
+        print(f"Extension downloaded to: {extension_path}")
+    else:
+        print("Failed to download extension")

fastled/{playwright_browser.py → playwright/playwright_browser.py}

@@ -52,19 +52,47 @@ def get_chromium_executable_path() -> str | None:
 class PlaywrightBrowser:
     """Playwright browser manager for FastLED sketches."""
 
-    def __init__(self, headless: bool = False):
+    def __init__(self, headless: bool = False, enable_extensions: bool = True):
         """Initialize the Playwright browser manager.
 
         Args:
             headless: Whether to run the browser in headless mode
+            enable_extensions: Whether to enable Chrome extensions (C++ DevTools Support)
         """
 
         self.headless = headless
+        self.enable_extensions = enable_extensions
         self.auto_resize = True  # Always enable auto-resize
         self.browser: Any = None
+        self.context: Any = None
         self.page: Any = None
         self.playwright: Any = None
         self._should_exit = asyncio.Event()
+        self._extensions_dir: Path | None = None
+
+        # Initialize extensions if enabled
+        if self.enable_extensions:
+            self._setup_extensions()
+
+    def _setup_extensions(self) -> None:
+        """Setup Chrome extensions for enhanced debugging."""
+        try:
+            from fastled.playwright.chrome_extension_downloader import (
+                download_cpp_devtools_extension,
+            )
+
+            extension_path = download_cpp_devtools_extension()
+            if extension_path and extension_path.exists():
+                self._extensions_dir = extension_path
+                print(
+                    f"[PYTHON] C++ DevTools Support extension ready: {extension_path}"
+                )
+            else:
+                print("[PYTHON] Warning: C++ DevTools Support extension not available")
+                self.enable_extensions = False
+        except Exception as e:
+            print(f"[PYTHON] Warning: Failed to setup Chrome extensions: {e}")
+            self.enable_extensions = False
 
     def _detect_device_scale_factor(self) -> float | None:
         """Detect the system's device scale factor for natural browser behavior.
@@ -74,92 +102,115 @@ class PlaywrightBrowser:
             the value is outside reasonable bounds (0.5-4.0).
         """
         try:
-            import platform
+            import tkinter
 
-            if platform.system() == "Windows":
-                import winreg
+            root = tkinter.Tk()
+            root.withdraw()  # Hide the window
+            scale_factor = root.winfo_fpixels("1i") / 72.0
+            root.destroy()
 
-                try:
-                    key = winreg.OpenKey(
-                        winreg.HKEY_CURRENT_USER, r"Control Panel\Desktop\WindowMetrics"
-                    )
-                    dpi, _ = winreg.QueryValueEx(key, "AppliedDPI")
-                    winreg.CloseKey(key)
-                    device_scale_factor = dpi / 96.0
-
-                    # Validate the scale factor is within reasonable bounds
-                    if 0.5 <= device_scale_factor <= 4.0:
-                        print(
-                            f"[PYTHON] Detected Windows DPI scaling: {device_scale_factor:.2f}"
-                        )
-                        return device_scale_factor
-                    else:
-                        print(
-                            f"[PYTHON] Detected scale factor {device_scale_factor:.2f} outside reasonable bounds"
-                        )
-                        return None
-
-                except (OSError, FileNotFoundError):
-                    print(
-                        "[PYTHON] Could not detect Windows DPI, using browser default"
-                    )
-                    return None
+            # Validate the scale factor is in a reasonable range
+            if 0.5 <= scale_factor <= 4.0:
+                return scale_factor
             else:
-                # Future: Add support for other platforms (macOS, Linux) here
                 print(
-                    f"[PYTHON] Device scale detection not implemented for {platform.system()}"
+                    f"[PYTHON] Detected scale factor {scale_factor:.2f} is outside reasonable bounds (0.5-4.0)"
                 )
                 return None
 
         except Exception as e:
-            print(f"[PYTHON] DPI detection failed: {e}")
+            print(f"[PYTHON] Could not detect device scale factor: {e}")
             return None
 
     async def start(self) -> None:
         """Start the Playwright browser."""
-        if self.browser is None:
+        if self.browser is None and self.context is None:
 
             from playwright.async_api import async_playwright
 
             self.playwright = async_playwright()
             playwright = await self.playwright.start()
 
-            # Get custom Chromium executable path if available
-            executable_path = get_chromium_executable_path()
-            launch_kwargs = {
-                "headless": self.headless,
-                "args": [
-                    "--disable-dev-shm-usage",
-                    "--disable-web-security",
-                    "--allow-running-insecure-content",
-                ],
-            }
-
-            if executable_path:
-                launch_kwargs["executable_path"] = executable_path
-                print(f"[PYTHON] Using custom Chromium executable: {executable_path}")
-
-            self.browser = await playwright.chromium.launch(**launch_kwargs)
-
-        if self.page is None and self.browser is not None:
-            # Detect system device scale factor for natural browser behavior
-            device_scale_factor = self._detect_device_scale_factor()
-
-            # Create browser context with detected or default device scale factor
-            if device_scale_factor:
-                context = await self.browser.new_context(
-                    device_scale_factor=device_scale_factor
+            if self.enable_extensions and self._extensions_dir:
+                # Use persistent context for extensions
+                user_data_dir = PLAYWRIGHT_DIR / "user-data"
+                user_data_dir.mkdir(parents=True, exist_ok=True)
+
+                launch_kwargs = {
+                    "headless": False,  # Extensions require headed mode
+                    "channel": "chromium",  # Required for extensions
+                    "args": [
+                        "--disable-dev-shm-usage",
+                        "--disable-web-security",
+                        "--allow-running-insecure-content",
+                        f"--disable-extensions-except={self._extensions_dir}",
+                        f"--load-extension={self._extensions_dir}",
+                    ],
+                }
+
+                # Get custom Chromium executable path if available
+                executable_path = get_chromium_executable_path()
+                if executable_path:
+                    launch_kwargs["executable_path"] = executable_path
+                    print(
+                        f"[PYTHON] Using custom Chromium executable: {executable_path}"
+                    )
+
+                self.context = await playwright.chromium.launch_persistent_context(
+                    str(user_data_dir), **launch_kwargs
                 )
+
                 print(
-                    f"[PYTHON] Created browser context with device scale factor: {device_scale_factor:.2f}"
+                    "[PYTHON] Started Playwright browser with C++ DevTools Support extension"
                 )
+
             else:
-                context = await self.browser.new_context()
-                print(
-                    "[PYTHON] Created browser context with default device scale factor"
-                )
+                # Regular browser launch without extensions
+                executable_path = get_chromium_executable_path()
+                launch_kwargs = {
+                    "headless": self.headless,
+                    "args": [
+                        "--disable-dev-shm-usage",
+                        "--disable-web-security",
+                        "--allow-running-insecure-content",
+                    ],
+                }
 
-            self.page = await context.new_page()
+                if executable_path:
+                    launch_kwargs["executable_path"] = executable_path
+                    print(
+                        f"[PYTHON] Using custom Chromium executable: {executable_path}"
+                    )
+
+                self.browser = await playwright.chromium.launch(**launch_kwargs)
+
+        if self.page is None:
+            if self.context:
+                # Using persistent context (with extensions)
+                if len(self.context.pages) > 0:
+                    self.page = self.context.pages[0]
+                else:
+                    self.page = await self.context.new_page()
+            elif self.browser:
+                # Using regular browser
+                # Detect system device scale factor for natural browser behavior
+                device_scale_factor = self._detect_device_scale_factor()
+
+                # Create browser context with detected or default device scale factor
+                if device_scale_factor:
+                    context = await self.browser.new_context(
+                        device_scale_factor=device_scale_factor
+                    )
+                    print(
+                        f"[PYTHON] Created browser context with device scale factor: {device_scale_factor:.2f}"
+                    )
+                else:
+                    context = await self.browser.new_context()
+                    print(
+                        "[PYTHON] Created browser context with default device scale factor"
+                    )
+
+                self.page = await context.new_page()
 
     async def open_url(self, url: str) -> None:
         """Open a URL in the Playwright browser.
@@ -190,6 +241,33 @@ class PlaywrightBrowser:
             if self.auto_resize:
                 await self._setup_auto_resize()
 
+            # Check if C++ DevTools extension is loaded
+            if self.enable_extensions and self._extensions_dir:
+                try:
+                    # Check if the extension is available in the DevTools
+                    extensions_available = await self.page.evaluate(
+                        """
+                        () => {
+                            // Check if chrome.devtools is available (extension context)
+                            return typeof chrome !== 'undefined' && 
+                                   typeof chrome.runtime !== 'undefined' &&
+                                   chrome.runtime.id !== undefined;
+                        }
+                    """
+                    )
+
+                    if extensions_available:
+                        print(
+                            "[PYTHON] ✅ C++ DevTools Support extension is active and ready for DWARF debugging"
+                        )
+                    else:
+                        print(
+                            "[PYTHON] ⚠️  C++ DevTools Support extension may not be fully loaded"
+                        )
+
+                except Exception as e:
+                    print(f"[PYTHON] Could not verify extension status: {e}")
+
     async def _setup_auto_resize(self) -> None:
         """Set up automatic window resizing based on content size."""
         if self.page is None:
@@ -203,119 +281,92 @@ class PlaywrightBrowser:
         # Start polling loop that tracks browser window changes and adjusts viewport only
         asyncio.create_task(self._track_browser_adjust_viewport())
 
-    async def _get_window_info(self) -> dict[str, int] | None:
-        """Get browser window dimensions information.
+    async def _track_browser_adjust_viewport(self) -> None:
+        """Track browser window changes and adjust viewport accordingly.
 
-        Returns:
-            Dictionary containing window dimensions or None if unable to retrieve
+        This method polls for changes in the browser window size and adjusts
+        the viewport size to match, maintaining the browser window dimensions
+        while ensuring the content area matches the sketch requirements.
         """
-        if self.page is None:
-            return None
+        last_viewport = None
+        consecutive_same_count = 0
+        max_consecutive_same = 5
 
-        try:
-            return await self.page.evaluate(
-                """
-                () => {
-                    return {
-                        outerWidth: window.outerWidth,
-                        outerHeight: window.outerHeight,
-                        innerWidth: window.innerWidth,
-                        innerHeight: window.innerHeight,
-                        contentWidth: document.documentElement.clientWidth,
-                        contentHeight: document.documentElement.clientHeight
-                    };
-                }
+        while not self._should_exit.is_set():
+            try:
+                await asyncio.sleep(0.5)  # Poll every 500ms
+
+                if self.page is None:
+                    continue
+
+                # Get current viewport size
+                current_viewport = await self.page.evaluate(
+                    """
+                    () => ({
+                        width: window.innerWidth,
+                        height: window.innerHeight
+                    })
                 """
-            )
-        except Exception:
-            return None
-
-    async def _track_browser_adjust_viewport(self) -> None:
-        """Track browser window outer size changes and adjust viewport accordingly."""
-        if self.page is None:
-            return
+                )
 
-        print(
-            "[PYTHON] Starting browser window tracking (outer size → viewport adjustment)"
-        )
-        last_outer_size = None
+                # Check if viewport changed
+                if current_viewport != last_viewport:
+                    last_viewport = current_viewport
+                    consecutive_same_count = 0
 
-        while True:
-            try:
-                # Wait 1 second between polls
-                await asyncio.sleep(1)
-
-                # Check if page is still alive
-                if self.page is None or self.page.is_closed():
-                    print("[PYTHON] Page closed, signaling exit")
-                    self._should_exit.set()
-                    return
-
-                # Get browser window dimensions
-                window_info = await self._get_window_info()
-
-                if window_info:
-                    current_outer = (
-                        window_info["outerWidth"],
-                        window_info["outerHeight"],
+                    print(
+                        f"[PYTHON] Viewport: {current_viewport['width']}x{current_viewport['height']}"
                     )
 
-                    # Print current state occasionally
-                    if last_outer_size is None or current_outer != last_outer_size:
-                        print(
-                            f"[PYTHON] Browser: outer={window_info['outerWidth']}x{window_info['outerHeight']}, content={window_info['contentWidth']}x{window_info['contentHeight']}"
+                    # Try to get window outer dimensions for context
+                    try:
+                        window_info = await self.page.evaluate(
+                            """
+                        () => ({
+                            outerWidth: window.outerWidth,
+                            outerHeight: window.outerHeight,
+                            screenX: window.screenX,
+                            screenY: window.screenY
+                        })
+                    """
                         )
 
-                    # Track changes in OUTER window size (user resizes browser)
-                    if last_outer_size is None or current_outer != last_outer_size:
-
-                        if last_outer_size is not None:
-                            print("[PYTHON] *** BROWSER WINDOW RESIZED ***")
-                            print(
-                                f"[PYTHON] Outer window changed from {last_outer_size[0]}x{last_outer_size[1]} to {current_outer[0]}x{current_outer[1]}"
-                            )
-
-                        last_outer_size = current_outer
-
-                        # Set viewport to match the outer window size
-                        if not self.headless:
-                            try:
-                                outer_width = int(window_info["outerWidth"])
-                                outer_height = int(window_info["outerHeight"])
-
-                                print(
-                                    f"[PYTHON] Setting viewport to match outer window size: {outer_width}x{outer_height}"
-                                )
-
-                                await self.page.set_viewport_size(
-                                    {"width": outer_width, "height": outer_height}
-                                )
-                                print("[PYTHON] Viewport set successfully")
-
-                                # Wait briefly for browser to settle after viewport change
-                                # await asyncio.sleep(0.5)
+                        print(
+                            f"[PYTHON] Window: {window_info['outerWidth']}x{window_info['outerHeight']} at ({window_info['screenX']}, {window_info['screenY']})"
+                        )
 
-                                # Query the actual window dimensions after the viewport change
-                                updated_window_info = await self._get_window_info()
+                    except Exception:
+                        pass
 
-                                if updated_window_info:
+                else:
+                    consecutive_same_count += 1
+                    if consecutive_same_count >= max_consecutive_same:
+                        # Viewport hasn't changed for a while, reduce polling frequency
+                        await asyncio.sleep(2.0)
+                        consecutive_same_count = 0
 
-                                    # Update our tracking with the actual final outer size
-                                    last_outer_size = (
-                                        updated_window_info["outerWidth"],
-                                        updated_window_info["outerHeight"],
-                                    )
-                                    print(
-                                        f"[PYTHON] Updated last_outer_size to actual final size: {last_outer_size}"
-                                    )
-                                else:
-                                    print("[PYTHON] Could not get updated window info")
+                # Get the browser window information periodically
+                try:
+                    browser_info = await self.page.evaluate(
+                        """
+                        () => {
+                            return {
+                                userAgent: navigator.userAgent,
+                                platform: navigator.platform,
+                                cookieEnabled: navigator.cookieEnabled,
+                                language: navigator.language
+                            };
+                        }
+                    """
+                    )
 
-                            except Exception as e:
-                                print(f"[PYTHON] Failed to set viewport: {e}")
+                    if browser_info:
+                        pass  # We have browser info, but don't need to print it constantly
+                    else:
+                        print("[PYTHON] Could not get browser window info")
 
-                else:
-                    print("[PYTHON] Could not get browser window info")
+                except Exception as e:
+                    print(f"[PYTHON] Could not get browser info: {e}")
 
             except Exception as e:
                 print(f"[PYTHON] Error in browser tracking: {e}")
@@ -323,15 +374,20 @@ class PlaywrightBrowser:
 
     async def wait_for_close(self) -> None:
         """Wait for the browser to be closed."""
-        if self.browser is None:
-            return
-
-        try:
-            # Wait for the browser to be closed
-            while not self.browser.is_closed():
-                await asyncio.sleep(1)
-        except Exception:
-            pass
+        if self.context:
+            # Wait for persistent context to be closed
+            try:
+                while not self.context.closed:
+                    await asyncio.sleep(1)
+            except Exception:
+                pass
+        elif self.browser:
+            try:
+                # Wait for the browser to be closed
+                while not self.browser.is_closed():
+                    await asyncio.sleep(1)
+            except Exception:
+                pass
 
     async def close(self) -> None:
         """Close the Playwright browser."""
@@ -339,6 +395,10 @@ class PlaywrightBrowser:
             await self.page.close()
             self.page = None
 
+        if self.context:
+            await self.context.close()
+            self.context = None
+
         if self.browser:
             await self.browser.close()
             self.browser = None
@@ -348,18 +408,23 @@ class PlaywrightBrowser:
             self.playwright = None
 
 
-def run_playwright_browser(url: str, headless: bool = False) -> None:
+def run_playwright_browser(
+    url: str, headless: bool = False, enable_extensions: bool = True
+) -> None:
     """Run Playwright browser in a separate process.
 
     Args:
         url: The URL to open
         headless: Whether to run in headless mode
+        enable_extensions: Whether to enable Chrome extensions (C++ DevTools Support)
     """
 
     async def main():
         browser = None
         try:
-            browser = PlaywrightBrowser(headless=headless)
+            browser = PlaywrightBrowser(
+                headless=headless, enable_extensions=enable_extensions
+            )
             await browser.start()
             await browser.open_url(url)
 
@@ -373,7 +438,9 @@ def run_playwright_browser(url: str, headless: bool = False) -> None:
                 if install_playwright_browsers():
                     print("🎭 Retrying browser startup...")
                     # Try again with fresh browser instance
-                    browser = PlaywrightBrowser(headless=headless)
+                    browser = PlaywrightBrowser(
+                        headless=headless, enable_extensions=enable_extensions
+                    )
                     await browser.start()
                     await browser.open_url(url)
 
@@ -413,12 +480,15 @@ class PlaywrightBrowserProxy:
         self.monitor_thread = None
         self._closing_intentionally = False
 
-    def open(self, url: str, headless: bool = False) -> None:
+    def open(
+        self, url: str, headless: bool = False, enable_extensions: bool = True
+    ) -> None:
         """Open URL with Playwright browser and keep it alive.
 
         Args:
             url: The URL to open
             headless: Whether to run in headless mode
+            enable_extensions: Whether to enable Chrome extensions (C++ DevTools Support)
         """
 
         try:
@@ -427,7 +497,7 @@ class PlaywrightBrowserProxy:
 
             self.process = multiprocessing.Process(
                 target=run_playwright_browser_persistent,
-                args=(url, headless),
+                args=(url, headless, enable_extensions),
             )
             self.process.start()
 
@@ -489,18 +559,23 @@ class PlaywrightBrowserProxy:
             self.process = None
 
 
-def run_playwright_browser_persistent(url: str, headless: bool = False) -> None:
+def run_playwright_browser_persistent(
+    url: str, headless: bool = False, enable_extensions: bool = True
+) -> None:
     """Run Playwright browser in a persistent mode that stays alive until terminated.
 
     Args:
         url: The URL to open
         headless: Whether to run in headless mode
+        enable_extensions: Whether to enable Chrome extensions (C++ DevTools Support)
     """
 
     async def main():
         browser = None
         try:
-            browser = PlaywrightBrowser(headless=headless)
+            browser = PlaywrightBrowser(
+                headless=headless, enable_extensions=enable_extensions
+            )
             await browser.start()
             await browser.open_url(url)
 
@@ -519,7 +594,9 @@ def run_playwright_browser_persistent(url: str, headless: bool = False) -> None:
                 if install_playwright_browsers():
                     print("🎭 Retrying browser startup...")
                     # Try again with fresh browser instance
-                    browser = PlaywrightBrowser(headless=headless)
+                    browser = PlaywrightBrowser(
+                        headless=headless, enable_extensions=enable_extensions
+                    )
                     await browser.start()
                     await browser.open_url(url)
 
@@ -552,7 +629,9 @@ def run_playwright_browser_persistent(url: str, headless: bool = False) -> None:
         print(f"Playwright browser failed: {e}")
 
 
-def open_with_playwright(url: str, headless: bool = False) -> PlaywrightBrowserProxy:
+def open_with_playwright(
+    url: str, headless: bool = False, enable_extensions: bool = True
+) -> PlaywrightBrowserProxy:
     """Open URL with Playwright browser and return a proxy object for lifecycle management.
 
     This function can be used as a drop-in replacement for webbrowser.open().
@@ -560,12 +639,13 @@ def open_with_playwright(url: str, headless: bool = False) -> PlaywrightBrowserP
     Args:
         url: The URL to open
         headless: Whether to run in headless mode
+        enable_extensions: Whether to enable Chrome extensions (C++ DevTools Support)
 
     Returns:
         PlaywrightBrowserProxy object for managing the browser lifecycle
     """
     proxy = PlaywrightBrowserProxy()
-    proxy.open(url, headless)
+    proxy.open(url, headless, enable_extensions)
     return proxy
 
 
@@ -623,6 +703,23 @@ def install_playwright_browsers() -> bool:
         if result.returncode == 0:
             print("✅ Playwright browsers installed successfully!")
             print(f"   Location: {playwright_dir}")
+
+            # Also download the C++ DevTools Support extension
+            try:
+                from fastled.playwright.chrome_extension_downloader import (
+                    download_cpp_devtools_extension,
+                )
+
+                extension_path = download_cpp_devtools_extension()
+                if extension_path:
+                    print(
+                        "✅ C++ DevTools Support extension ready for DWARF debugging!"
+                    )
+                else:
+                    print("⚠️  C++ DevTools Support extension download failed")
+            except Exception as e:
+                print(f"⚠️  Failed to setup C++ DevTools Support extension: {e}")
+
             return True
         else:
             print(

fastled/web_compile.py

@@ -9,13 +9,14 @@ from pathlib import Path
 import httpx
 
 from fastled.find_good_connection import find_good_connection
+from fastled.interruptible_http import make_interruptible_post_request
 from fastled.settings import SERVER_PORT
 from fastled.types import BuildMode, CompileResult
 from fastled.zip_files import ZipResult, zip_files
 
 DEFAULT_HOST = "https://fastled.onrender.com"
 ENDPOINT_COMPILED_WASM = "compile/wasm"
-_TIMEOUT = 60 * 4  # 2 mins timeout
+_TIMEOUT = 60 * 4  # 4 mins timeout
 _AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
 
 
@@ -83,25 +84,26 @@ def _compile_libfastled(
         httpx.HTTPTransport(local_address="0.0.0.0") if connection_result.ipv4 else None
     )
 
-    with httpx.Client(
+    headers = {
+        "accept": "application/json",
+        "authorization": auth_token,
+        "build": build_mode.value.lower(),
+    }
+
+    url = f"{connection_result.host}/compile/libfastled"
+    print(f"Compiling libfastled on {url} via {ipv4_stmt}")
+
+    # Use interruptible HTTP request
+    response = make_interruptible_post_request(
+        url=url,
+        files={},  # No files for libfastled compilation
+        headers=headers,
         transport=transport,
         timeout=_TIMEOUT * 2,  # Give more time for library compilation
-    ) as client:
-        headers = {
-            "accept": "application/json",
-            "authorization": auth_token,
-            "build": build_mode.value.lower(),
-        }
-
-        url = f"{connection_result.host}/compile/libfastled"
-        print(f"Compiling libfastled on {url} via {ipv4_stmt}")
-        response = client.post(
-            url,
-            headers=headers,
-            timeout=_TIMEOUT * 2,
-        )
+        follow_redirects=False,
+    )
 
-        return response
+    return response
 
 
 def _send_compile_request(
@@ -131,37 +133,32 @@ def _send_compile_request(
 
     archive_size = len(zip_bytes)
 
-    with httpx.Client(
+    headers = {
+        "accept": "application/json",
+        "authorization": auth_token,
+        "build": (
+            build_mode.value.lower() if build_mode else BuildMode.QUICK.value.lower()
+        ),
+        "profile": "true" if profile else "false",
+        "no-platformio": "true" if no_platformio else "false",
+        "allow-libcompile": "false",  # Always false since we handle it manually
+    }
+
+    url = f"{connection_result.host}/{ENDPOINT_COMPILED_WASM}"
+    print(f"Compiling sketch on {url} via {ipv4_stmt}. Zip size: {archive_size} bytes")
+    files = {"file": ("wasm.zip", zip_bytes, "application/x-zip-compressed")}
+
+    # Use interruptible HTTP request
+    response = make_interruptible_post_request(
+        url=url,
+        files=files,
+        headers=headers,
         transport=transport,
         timeout=_TIMEOUT,
-    ) as client:
-        headers = {
-            "accept": "application/json",
-            "authorization": auth_token,
-            "build": (
-                build_mode.value.lower()
-                if build_mode
-                else BuildMode.QUICK.value.lower()
-            ),
-            "profile": "true" if profile else "false",
-            "no-platformio": "true" if no_platformio else "false",
-            "allow-libcompile": "false",  # Always false since we handle it manually
-        }
-
-        url = f"{connection_result.host}/{ENDPOINT_COMPILED_WASM}"
-        print(
-            f"Compiling sketch on {url} via {ipv4_stmt}. Zip size: {archive_size} bytes"
-        )
-        files = {"file": ("wasm.zip", zip_bytes, "application/x-zip-compressed")}
-        response = client.post(
-            url,
-            follow_redirects=True,
-            files=files,
-            headers=headers,
-            timeout=_TIMEOUT,
-        )
+        follow_redirects=True,
+    )
 
-        return response
+    return response
 
 
 def _process_compile_response(

{fastled-1.4.8.dist-info → fastled-1.4.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.4.8
+Version: 1.4.10
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies

{fastled-1.4.8.dist-info → fastled-1.4.10.dist-info}/RECORD

@@ -1,6 +1,6 @@
 fastled/__init__.py,sha256=dahiY41HLLotTjqmpVJmXSwUEp8NKqoZ57jt55hBLa4,7667
 fastled/__main__.py,sha256=OcKv2ER1_iQAsZzLIUb3C8hRC9L2clNOhCrjpshrlf4,336
-fastled/__version__.py,sha256=_2ywp7KhqGJZb6YoOQ07zDtMr2v_9j2-5miU6u4w6_c,372
+fastled/__version__.py,sha256=79y56vY5gQySq33JTd8MFfXtNmylXNSfvohTya9mP_M,373
 fastled/app.py,sha256=6XOuObi72AUnZXASDOVbcSflr4He0xnIDk5P8nVmVus,6131
 fastled/args.py,sha256=d8Afa7NMcNLMIQqIBX_ZOL5JOyeJ7XCch4LdkhFNChk,3671
 fastled/cli.py,sha256=drgR2AOxVrj3QEz58iiKscYAumbbin2vIV-k91VCOAA,561
@@ -12,13 +12,13 @@ fastled/compile_server_impl.py,sha256=iCwNCs7YxypUuVPmY4979mOgoH9OiuAJa1a1bmpG1c
 fastled/docker_manager.py,sha256=rkq39ZKrU6NHIyDa3mzs0Unb6o9oMeAwxhqiuHJU_RY,40291
 fastled/filewatcher.py,sha256=gEcJJHTDJ1X3gKJzltmEBhixWGbZj2eJD7a4vwSvITQ,10036
 fastled/find_good_connection.py,sha256=xnrJjrbwNZUkvSQRn_ZTMoVh5GBWTbO-lEsr_L95xq8,3372
+fastled/interruptible_http.py,sha256=2QwUsRNJ1qawf_-Lp1l0dBady3TK0SrBFhmnWgM7oqg,4888
 fastled/keyboard.py,sha256=UTAsqCn1UMYnB8YDzENiLTj4GeL45tYfEcO7_5fLFEg,3556
 fastled/keyz.py,sha256=LO-8m_7CpNDiZLM-FXhQ30f9gN1bUYz5lOsUPTIbI-c,4020
 fastled/live_client.py,sha256=yp_ujG92EHYpSedGOUteuG2nQvMKbp1GbUpgQ6nU4Dc,3083
-fastled/open_browser.py,sha256=xyUQmLL0D05AMyc3TIYUtFFLCeO7uBra8HeTnxAjcCQ,4847
+fastled/open_browser.py,sha256=N0d_D87sSBOUbBUl7gktJufdyM1laEKIERCXnEYCyu4,5086
 fastled/parse_args.py,sha256=UiGgFoR_7ZCVC26rxE4FpxpmPu9xBhiiCD4pwmY_gLw,11520
 fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
-fastled/playwright_browser.py,sha256=2hHcVLSr3QkV3C-CWjmWXWKNDzychKbuQRHSXJA55Ms,22895
 fastled/print_filter.py,sha256=nc_rqYYdCUPinFycaK7fiQF5PG1up51pmJptR__QyAs,1499
 fastled/project_init.py,sha256=bBt4DwmW5hZkm9ICt9Qk-0Nr_0JQM7icCgH5Iv-bCQs,3984
 fastled/select_sketch_directory.py,sha256=-eudwCns3AKj4HuHtSkZAFwbnf005SNL07pOzs9VxnE,1383
@@ -31,18 +31,20 @@ fastled/string_diff.py,sha256=oTncu0qYdLlLUtYLLDB4bzdQ2OfzegAR6XNAzwE9fIs,6002
 fastled/types.py,sha256=ZDf1TbTT4XgA_pKIwr4JbkDB38_29ogSdDORjoT-zuY,1803
 fastled/util.py,sha256=TjhXbUNh4p2BGhNAldSeL68B7BBOjsWAXji5gy-vDEQ,1440
 fastled/version.py,sha256=TpBMiEVdO3_sUZEu6wmwN8Q4AgX2BiCxStCsnPKh6E0,1209
-fastled/web_compile.py,sha256=Ql2DBRInZy7dOr1WZiUlhdg1ZVuU1nkbndRWiq7iENQ,10002
+fastled/web_compile.py,sha256=8wJ6EK01hHsQLfeon4_TQaEDQZjsHHPidPPIzjMYUuM,9960
 fastled/zip_files.py,sha256=BgHFjaLJ7wF6mnzjqOgn76VcKDwhwc_-w_qyUG_-aNs,2815
 fastled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
 fastled/assets/localhost-key.pem,sha256=Q-CNO_UoOd8fFNN4ljcnqwUeCMhzTplRjLO2x0pYRlU,1704
 fastled/assets/localhost.pem,sha256=QTwUtTwjYWbm9m3pHW2IlK2nFZJ8b0pppxPjhgVZqQo,1619
+fastled/playwright/chrome_extension_downloader.py,sha256=48YyQrsuK1TVXPuAvRGzqkQJnx0991Ka6OVUo1A58zU,7079
+fastled/playwright/playwright_browser.py,sha256=5cx80kEV72CPlBT9fIcJNc9z40EFSOfXchBKBE9R4sE,26798
 fastled/site/build.py,sha256=2YKU_UWKlJdGnjdbAbaL0co6kceFMSTVYwH1KCmgPZA,13987
 fastled/site/examples.py,sha256=s6vj2zJc6BfKlnbwXr1QWY1mzuDBMt6j5MEBOWjO_U8,155
 fastled/test/can_run_local_docker_tests.py,sha256=LEuUbHctRhNNFWcvnz2kEGmjDJeXO4c3kNpizm3yVJs,400
 fastled/test/examples.py,sha256=GfaHeY1E8izBl6ZqDVjz--RHLyVR4NRnQ5pBesCFJFY,1673
-fastled-1.4.8.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-fastled-1.4.8.dist-info/METADATA,sha256=OtWn1uaXyCtBaTLs4HV7IVhMDcUWsxUYOboe50UXlXY,31909
-fastled-1.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fastled-1.4.8.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
-fastled-1.4.8.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
-fastled-1.4.8.dist-info/RECORD,,
+fastled-1.4.10.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.4.10.dist-info/METADATA,sha256=ZUfEDRHSSsMmIZSZ4j3FCypY9lIZ4Yxuloo4HfU9QIc,31910
+fastled-1.4.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fastled-1.4.10.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.4.10.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
+fastled-1.4.10.dist-info/RECORD,,