fastled 1.4.8__tar.gz → 1.4.10__tar.gz

{fastled-1.4.8 → fastled-1.4.10}/PKG-INFO

@@ -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.10/requirements.docker.txt

@@ -0,0 +1 @@
+fastled-wasm-server>=1.1.18

{fastled-1.4.8 → fastled-1.4.10}/src/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-1.4.10/src/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-1.4.8 → fastled-1.4.10}/src/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-1.4.10/src/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")