fastled 1.4.9__tar.gz → 1.4.11__tar.gz

{fastled-1.4.9 → fastled-1.4.11}/PKG-INFO

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

fastled-1.4.11/requirements.docker.txt

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

{fastled-1.4.9 → fastled-1.4.11}/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.9"
+__version__ = "1.4.11"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

fastled-1.4.11/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.9 → fastled-1.4.11}/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()
 

{fastled-1.4.9/src/fastled → fastled-1.4.11/src/fastled/playwright}/playwright_browser.py

@@ -77,7 +77,7 @@ class PlaywrightBrowser:
     def _setup_extensions(self) -> None:
         """Setup Chrome extensions for enhanced debugging."""
         try:
-            from fastled.chrome_extension_downloader import (
+            from fastled.playwright.chrome_extension_downloader import (
                 download_cpp_devtools_extension,
             )
 
@@ -706,7 +706,7 @@ def install_playwright_browsers() -> bool:
 
             # Also download the C++ DevTools Support extension
             try:
-                from fastled.chrome_extension_downloader import (
+                from fastled.playwright.chrome_extension_downloader import (
                     download_cpp_devtools_extension,
                 )
 

{fastled-1.4.9 → fastled-1.4.11}/src/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"
 
 
@@ -29,6 +30,38 @@ def _sanitize_host(host: str) -> str:
     return host if host.startswith("http://") else f"http://{host}"
 
 
+def _check_embedded_http_status(response_content: bytes) -> tuple[bool, int | None]:
+    """
+    Check if the response content has an embedded HTTP status at the end.
+
+    Returns:
+        tuple: (has_embedded_status, status_code)
+               has_embedded_status is True if an embedded status was found
+               status_code is the embedded status code or None if not found
+    """
+    try:
+        # Convert bytes to string for parsing
+        content_str = response_content.decode("utf-8", errors="ignore")
+
+        # Look for HTTP_STATUS: at the end of the content
+        lines = content_str.strip().split("\n")
+        if lines:
+            last_line = lines[-1].strip()
+            if last_line.startswith("HTTP_STATUS:"):
+                # Extract the status code
+                try:
+                    status_code = int(last_line.split(":", 1)[1].strip())
+                    return True, status_code
+                except (ValueError, IndexError):
+                    # Malformed status line
+                    return True, None
+
+        return False, None
+    except Exception:
+        # If we can't parse the content, assume no embedded status
+        return False, None
+
+
 def _banner(msg: str) -> str:
     """
     Create a banner for the given message.
@@ -83,25 +116,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 +165,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(
@@ -264,13 +293,33 @@ def web_compile(
             print("Step 1: Compiling libfastled...")
             try:
                 libfastled_response = _compile_libfastled(host, auth_token, build_mode)
+
+                # Check HTTP response status first
                 if libfastled_response.status_code != 200:
                     print(
-                        f"Warning: libfastled compilation failed with status {libfastled_response.status_code}"
+                        f"Warning: libfastled compilation failed with HTTP status {libfastled_response.status_code}"
                     )
                     # Continue with sketch compilation even if libfastled fails
                 else:
-                    print("✅ libfastled compilation successful")
+                    # Check for embedded HTTP status in response content
+                    has_embedded_status, embedded_status = _check_embedded_http_status(
+                        libfastled_response.content
+                    )
+                    if has_embedded_status:
+                        if embedded_status is not None and embedded_status != 200:
+                            print(
+                                f"Warning: libfastled compilation failed with embedded status {embedded_status}"
+                            )
+                            # Continue with sketch compilation even if libfastled fails
+                        elif embedded_status is None:
+                            print(
+                                "Warning: libfastled compilation returned malformed embedded status"
+                            )
+                            # Continue with sketch compilation even if libfastled fails
+                        else:
+                            print("✅ libfastled compilation successful")
+                    else:
+                        print("✅ libfastled compilation successful")
             except Exception as e:
                 print(f"Warning: libfastled compilation failed: {e}")
                 # Continue with sketch compilation even if libfastled fails

{fastled-1.4.9 → fastled-1.4.11}/src/fastled.egg-info/PKG-INFO

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

{fastled-1.4.9 → fastled-1.4.11}/src/fastled.egg-info/SOURCES.txt

@@ -50,7 +50,6 @@ src/fastled/__main__.py
 src/fastled/__version__.py
 src/fastled/app.py
 src/fastled/args.py
-src/fastled/chrome_extension_downloader.py
 src/fastled/cli.py
 src/fastled/cli_test.py
 src/fastled/cli_test_interactive.py
@@ -60,13 +59,13 @@ src/fastled/compile_server_impl.py
 src/fastled/docker_manager.py
 src/fastled/filewatcher.py
 src/fastled/find_good_connection.py
+src/fastled/interruptible_http.py
 src/fastled/keyboard.py
 src/fastled/keyz.py
 src/fastled/live_client.py
 src/fastled/open_browser.py
 src/fastled/parse_args.py
 src/fastled/paths.py
-src/fastled/playwright_browser.py
 src/fastled/print_filter.py
 src/fastled/project_init.py
 src/fastled/select_sketch_directory.py
@@ -90,6 +89,8 @@ src/fastled.egg-info/top_level.txt
 src/fastled/assets/example.txt
 src/fastled/assets/localhost-key.pem
 src/fastled/assets/localhost.pem
+src/fastled/playwright/chrome_extension_downloader.py
+src/fastled/playwright/playwright_browser.py
 src/fastled/site/build.py
 src/fastled/site/examples.py
 src/fastled/test/can_run_local_docker_tests.py

{fastled-1.4.9 → fastled-1.4.11}/tests/integration/test_playwright_integration.py

@@ -5,7 +5,7 @@ Unit tests for Playwright integration.
 import unittest
 from unittest.mock import MagicMock, patch
 
-from fastled.playwright_browser import open_with_playwright
+from fastled.playwright.playwright_browser import open_with_playwright
 
 
 class PlaywrightIntegrationTester(unittest.TestCase):

fastled-1.4.11/tests/unit/test_webcompile.py

@@ -0,0 +1,81 @@
+import time
+import unittest
+from pathlib import Path
+
+from fastled.web_compile import _check_embedded_http_status, web_compile
+
+HERE = Path(__file__).parent
+TEST_DIR = HERE / "test_ino" / "wasm"
+
+_USE_LOCALHOST = False
+_HOST = "http://localhost" if _USE_LOCALHOST else None
+
+
+class WebCompileTester(unittest.TestCase):
+    """Main tester class."""
+
+    def test_compile(self) -> None:
+        """Test web compilation functionality with real server."""
+        # Test the web_compile function with actual server call
+        start = time.time()
+        result = web_compile(TEST_DIR, host=_HOST)
+        diff = time.time() - start
+        print(f"Time taken: {diff:.2f} seconds")
+
+        # Verify we got a successful result
+        self.assertTrue(result.success, f"Compilation failed: {result.stdout}")
+
+        # Verify we got actual WASM data back
+        self.assertTrue(len(result.zip_bytes) > 0)
+
+        # Print compilation output for debugging
+        print(f"Compilation stdout:\n{result.stdout}")
+
+        print(f"Zip size: {len(result.zip_bytes)} bytes")
+
+    def test_invalid_directory(self) -> None:
+        """Test handling of invalid directory."""
+        with self.assertRaises(FileNotFoundError):
+            web_compile(Path("nonexistent_directory"))
+
+    def test_embedded_http_status_parsing(self) -> None:
+        """Test the _check_embedded_http_status function."""
+        # Test successful case (no embedded status)
+        content_success = b"Some output\nCompilation successful\n"
+        has_status, status_code = _check_embedded_http_status(content_success)
+        self.assertFalse(has_status)
+        self.assertIsNone(status_code)
+
+        # Test embedded 400 status
+        content_400 = b"Some error output\nHTTP_STATUS: 400"
+        has_status, status_code = _check_embedded_http_status(content_400)
+        self.assertTrue(has_status)
+        self.assertEqual(status_code, 400)
+
+        # Test embedded 200 status
+        content_200 = b"Some output\nHTTP_STATUS: 200"
+        has_status, status_code = _check_embedded_http_status(content_200)
+        self.assertTrue(has_status)
+        self.assertEqual(status_code, 200)
+
+        # Test malformed embedded status
+        content_malformed = b"Some output\nHTTP_STATUS: invalid"
+        has_status, status_code = _check_embedded_http_status(content_malformed)
+        self.assertTrue(has_status)
+        self.assertIsNone(status_code)
+
+        # Test empty content
+        content_empty = b""
+        has_status, status_code = _check_embedded_http_status(content_empty)
+        self.assertFalse(has_status)
+        self.assertIsNone(status_code)
+
+        # Test content with embedded status in middle (should not be detected)
+        content_middle = b"Some output\nHTTP_STATUS: 400\nMore output"
+        has_status, status_code = _check_embedded_http_status(content_middle)
+        self.assertFalse(has_status)
+        self.assertIsNone(status_code)
+
+
+if __name__ == "__main__":
+    unittest.main()

fastled-1.4.9/requirements.docker.txt

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

fastled-1.4.9/tests/unit/test_webcompile.py

@@ -1,43 +0,0 @@
-import time
-import unittest
-from pathlib import Path
-
-from fastled.web_compile import web_compile
-
-HERE = Path(__file__).parent
-TEST_DIR = HERE / "test_ino" / "wasm"
-
-_USE_LOCALHOST = False
-_HOST = "http://localhost" if _USE_LOCALHOST else None
-
-
-class WebCompileTester(unittest.TestCase):
-    """Main tester class."""
-
-    def test_compile(self) -> None:
-        """Test web compilation functionality with real server."""
-        # Test the web_compile function with actual server call
-        start = time.time()
-        result = web_compile(TEST_DIR, host=_HOST)
-        diff = time.time() - start
-        print(f"Time taken: {diff:.2f} seconds")
-
-        # Verify we got a successful result
-        self.assertTrue(result.success, f"Compilation failed: {result.stdout}")
-
-        # Verify we got actual WASM data back
-        self.assertTrue(len(result.zip_bytes) > 0)
-
-        # Print compilation output for debugging
-        print(f"Compilation stdout:\n{result.stdout}")
-
-        print(f"Zip size: {len(result.zip_bytes)} bytes")
-
-    def test_invalid_directory(self) -> None:
-        """Test handling of invalid directory."""
-        with self.assertRaises(FileNotFoundError):
-            web_compile(Path("nonexistent_directory"))
-
-
-if __name__ == "__main__":
-    unittest.main()