fastled 1.4.2__tar.gz → 1.4.4__tar.gz

{fastled-1.4.2 → fastled-1.4.4}/PKG-INFO

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

fastled-1.4.4/requirements.docker.txt

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

{fastled-1.4.2 → fastled-1.4.4}/src/fastled/__init__.py

@@ -41,18 +41,29 @@ class Api:
         profile: bool = False,  # When true then profile information will be enabled and included in the zip.
         no_platformio: bool = False,
     ) -> CompileResult:
+        from fastled.sketch import looks_like_fastled_repo
         from fastled.web_compile import web_compile
 
         if isinstance(host, CompileServer):
             host = host.url()
         if isinstance(directory, str):
             directory = Path(directory)
+
+        # Guard: libfastled compilation requires volume source mapping
+        # Only allow libcompile if we're in a FastLED repository
+        allow_libcompile = looks_like_fastled_repo(Path(".").resolve())
+        if not allow_libcompile:
+            print(
+                "⚠️  libfastled compilation disabled: not running in FastLED repository"
+            )
+
         out: CompileResult = web_compile(
             directory,
             host,
             build_mode=build_mode,
             profile=profile,
             no_platformio=no_platformio,
+            allow_libcompile=allow_libcompile,
         )
         return out
 

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

{fastled-1.4.2 → fastled-1.4.4}/src/fastled/client_server.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from fastled.compile_server import CompileServer
 from fastled.docker_manager import DockerManager
 from fastled.filewatcher import DebouncedFileWatcherProcess, FileWatcherProcess
+from fastled.find_good_connection import ConnectionResult
 from fastled.keyboard import SpaceBarWatcher
 from fastled.open_browser import spawn_http_server
 from fastled.parse_args import Args
@@ -19,7 +20,6 @@ from fastled.sketch import looks_like_sketch_directory
 from fastled.types import BuildMode, CompileResult, CompileServerError
 from fastled.web_compile import (
     SERVER_PORT,
-    ConnectionResult,
     find_good_connection,
     web_compile,
 )
@@ -101,9 +101,17 @@ def _run_web_compiler(
     profile: bool,
     last_hash_value: str | None,
     no_platformio: bool = False,
+    allow_libcompile: bool = False,
 ) -> CompileResult:
+    # Remove the import and libcompile detection logic from here
+    # since it will now be passed as a parameter
     input_dir = Path(directory)
     output_dir = input_dir / "fastled_js"
+
+    # Guard: libfastled compilation requires volume source mapping
+    if not allow_libcompile:
+        print("⚠️  libfastled compilation disabled: not running in FastLED repository")
+
     start = time.time()
     web_result = web_compile(
         directory=input_dir,
@@ -111,6 +119,7 @@ def _run_web_compiler(
         build_mode=build_mode,
         profile=profile,
         no_platformio=no_platformio,
+        allow_libcompile=allow_libcompile,
     )
     diff = time.time() - start
     if not web_result.success:
@@ -310,6 +319,11 @@ def run_client(
         # Assume default port for www
         port = 80
 
+    # Auto-detect libcompile capability on first call
+    from fastled.sketch import looks_like_fastled_repo
+
+    allow_libcompile = looks_like_fastled_repo(Path(".").resolve())
+
     try:
 
         def compile_function(
@@ -318,6 +332,7 @@ def run_client(
             profile: bool = profile,
             last_hash_value: str | None = None,
             no_platformio: bool = no_platformio,
+            allow_libcompile: bool = allow_libcompile,
         ) -> CompileResult:
             TEST_BEFORE_COMPILE(url)
             return _run_web_compiler(
@@ -327,6 +342,7 @@ def run_client(
                 profile=profile,
                 last_hash_value=last_hash_value,
                 no_platformio=no_platformio,
+                allow_libcompile=allow_libcompile,
             )
 
         result: CompileResult = compile_function(last_hash_value=None)
@@ -454,6 +470,10 @@ def run_client(
                 if changed_files:
                     print(f"\nChanges detected in FastLED source code: {changed_files}")
                     print("Press space bar to trigger compile.")
+
+                    # Re-evaluate libcompile capability when source code changes
+                    allow_libcompile = True
+
                     while True:
                         space_bar_pressed = SpaceBarWatcher.watch_space_bar_pressed(
                             timeout=1.0
@@ -476,8 +496,9 @@ def run_client(
                                     f"Changes detected in {','.join(sketch_files_changed)}, triggering recompile..."
                                 )
                             last_compiled_result = compile_function(
-                                last_hash_value=None
+                                last_hash_value=None, allow_libcompile=allow_libcompile
                             )
+                            allow_libcompile = False
                             print("Finished recompile.")
                             # Drain the space bar queue
                             SpaceBarWatcher.watch_space_bar_pressed()

{fastled-1.4.2 → fastled-1.4.4}/src/fastled/compile_server.py

@@ -16,6 +16,7 @@ class CompileServer:
         platform: Platform = Platform.WASM,
         remove_previous: bool = False,
         no_platformio: bool = False,
+        allow_libcompile: bool = True,
     ) -> None:
         from fastled.compile_server_impl import (  # avoid circular import
             CompileServerImpl,
@@ -31,6 +32,7 @@ class CompileServer:
             auto_start=auto_start,
             remove_previous=remove_previous,
             no_platformio=no_platformio,
+            allow_libcompile=allow_libcompile,
         )
 
     # May throw CompileServerError if server could not be started.

{fastled-1.4.2 → fastled-1.4.4}/src/fastled/compile_server_impl.py

@@ -51,6 +51,7 @@ class CompileServerImpl:
         container_name: str | None = None,
         remove_previous: bool = False,
         no_platformio: bool = False,
+        allow_libcompile: bool = True,
     ) -> None:
         container_name = container_name or DEFAULT_CONTAINER_NAME
         if interactive and not mapped_dir:
@@ -70,6 +71,17 @@ class CompileServerImpl:
         self.auto_updates = auto_updates
         self.remove_previous = remove_previous
         self.no_platformio = no_platformio
+
+        # Guard: libfastled compilation requires volume source mapping
+        # If we don't have fastled_src_dir (not in FastLED repo), disable libcompile
+        if allow_libcompile and self.fastled_src_dir is None:
+            print(
+                "⚠️  libfastled compilation disabled: volume source mapping not available"
+            )
+            print("   (not running in FastLED repository)")
+            allow_libcompile = False
+
+        self.allow_libcompile = allow_libcompile
         self._port = 0  # 0 until compile server is started
         if auto_start:
             self.start()
@@ -112,6 +124,7 @@ class CompileServerImpl:
             build_mode=build_mode,
             profile=profile,
             no_platformio=self.no_platformio,
+            allow_libcompile=self.allow_libcompile,
         )
         return out
 

fastled-1.4.4/src/fastled/find_good_connection.py

@@ -0,0 +1,105 @@
+import _thread
+import time
+from concurrent.futures import Future, ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from typing import Dict, Tuple
+
+import httpx
+
+_TIMEOUT = 30.0
+
+_EXECUTOR = ThreadPoolExecutor(max_workers=8)
+
+# In-memory cache for connection results
+# Key: (tuple of urls, filter_out_bad, use_ipv6)
+# Value: (ConnectionResult | None, timestamp)
+_CONNECTION_CACHE: Dict[
+    Tuple[tuple, bool, bool], Tuple["ConnectionResult | None", float]
+] = {}
+_CACHE_TTL = 60.0 * 60.0  # Cache results for 1 hour
+
+
+@dataclass
+class ConnectionResult:
+    host: str
+    success: bool
+    ipv4: bool
+
+
+def _sanitize_host(host: str) -> str:
+    if host.startswith("http"):
+        return host
+    is_local_host = "localhost" in host or "127.0.0.1" in host or "0.0.0.0" in host
+    use_https = not is_local_host
+    if use_https:
+        return host if host.startswith("https://") else f"https://{host}"
+    return host if host.startswith("http://") else f"http://{host}"
+
+
+def _test_connection(host: str, use_ipv4: bool) -> ConnectionResult:
+    # Function static cache
+    host = _sanitize_host(host)
+    transport = httpx.HTTPTransport(local_address="0.0.0.0") if use_ipv4 else None
+    result: ConnectionResult | None = None
+    try:
+        with httpx.Client(
+            timeout=_TIMEOUT,
+            transport=transport,
+        ) as test_client:
+            test_response = test_client.get(
+                f"{host}/healthz", timeout=3, follow_redirects=True
+            )
+            result = ConnectionResult(host, test_response.status_code == 200, use_ipv4)
+    except KeyboardInterrupt:
+        _thread.interrupt_main()
+        result = ConnectionResult(host, False, use_ipv4)
+    except TimeoutError:
+        result = ConnectionResult(host, False, use_ipv4)
+    except Exception:
+        result = ConnectionResult(host, False, use_ipv4)
+    return result
+
+
+def find_good_connection(
+    urls: list[str], filter_out_bad=True, use_ipv6: bool = True
+) -> ConnectionResult | None:
+    # Create cache key from parameters
+    cache_key = (tuple(sorted(urls)), filter_out_bad, use_ipv6)
+    current_time = time.time()
+
+    # Check if we have a cached result
+    if cache_key in _CONNECTION_CACHE:
+        cached_result, cached_time = _CONNECTION_CACHE[cache_key]
+        if current_time - cached_time < _CACHE_TTL:
+            return cached_result
+        else:
+            # Remove expired cache entry
+            del _CONNECTION_CACHE[cache_key]
+
+    # No valid cache entry, perform the actual connection test
+    futures: list[Future] = []
+    for url in urls:
+
+        f = _EXECUTOR.submit(_test_connection, url, use_ipv4=True)
+        futures.append(f)
+        if use_ipv6 and "localhost" not in url:
+            f_v6 = _EXECUTOR.submit(_test_connection, url, use_ipv4=False)
+            futures.append(f_v6)
+
+    result = None
+    try:
+        # Return first successful result
+        for future in as_completed(futures):
+            connection_result: ConnectionResult = future.result()
+            if connection_result.success or not filter_out_bad:
+                result = connection_result
+                break
+    finally:
+        # Cancel any remaining futures
+        for future in futures:
+            future.cancel()
+
+    # Cache the result (even if None)
+    _CONNECTION_CACHE[cache_key] = (result, current_time)
+
+    return result

{fastled-1.4.2 → fastled-1.4.4}/src/fastled/playwright_browser.py

@@ -79,8 +79,83 @@ class PlaywrightBrowser:
                     )
 
         if self.page is None and self.browser is not None:
-            # Create a new browser context and page
-            context = await self.browser.new_context()
+            # Detect system device scale factor to match normal browser behavior
+            import platform
+
+            device_scale_factor = 1.0
+
+            # Try to detect system display scaling
+            try:
+                if platform.system() == "Windows":
+                    # On Windows, try to get the DPI scaling factor
+                    import ctypes
+
+                    try:
+                        # Get DPI awareness and scale factor
+                        user32 = ctypes.windll.user32
+                        user32.SetProcessDPIAware()
+                        dc = user32.GetDC(0)
+                        dpi = ctypes.windll.gdi32.GetDeviceCaps(dc, 88)  # LOGPIXELSX
+                        user32.ReleaseDC(0, dc)
+                        device_scale_factor = dpi / 96.0  # 96 DPI is 100% scaling
+                    except Exception:
+                        # Fallback: try alternative method
+                        try:
+                            import tkinter as tk
+
+                            root = tk.Tk()
+                            device_scale_factor = root.winfo_fpixels("1i") / 96.0
+                            root.destroy()
+                        except Exception:
+                            pass
+                elif platform.system() == "Darwin":  # macOS
+                    # On macOS, try to get the display scaling
+                    try:
+                        import subprocess
+
+                        result = subprocess.run(
+                            ["system_profiler", "SPDisplaysDataType"],
+                            capture_output=True,
+                            text=True,
+                            timeout=5,
+                        )
+                        if "Retina" in result.stdout or "2x" in result.stdout:
+                            device_scale_factor = 2.0
+                        elif "3x" in result.stdout:
+                            device_scale_factor = 3.0
+                    except Exception:
+                        pass
+                elif platform.system() == "Linux":
+                    # On Linux, try to get display scaling from environment or system
+                    try:
+                        import os
+
+                        # Try GDK scaling first
+                        gdk_scale = os.environ.get("GDK_SCALE")
+                        if gdk_scale:
+                            device_scale_factor = float(gdk_scale)
+                        else:
+                            # Try QT scaling
+                            qt_scale = os.environ.get("QT_SCALE_FACTOR")
+                            if qt_scale:
+                                device_scale_factor = float(qt_scale)
+                    except Exception:
+                        pass
+            except Exception:
+                # If all detection methods fail, default to 1.0
+                device_scale_factor = 1.0
+
+            # Ensure device scale factor is reasonable (between 0.5 and 4.0)
+            device_scale_factor = max(0.5, min(4.0, device_scale_factor))
+
+            print(f"[PYTHON] Detected device scale factor: {device_scale_factor}")
+
+            # Create a new browser context with proper device scale factor
+            context = await self.browser.new_context(
+                device_scale_factor=device_scale_factor,
+                # Also ensure viewport scaling is handled properly
+                viewport={"width": 1280, "height": 720} if not self.headless else None,
+            )
             self.page = await context.new_page()
 
     async def open_url(self, url: str) -> None:

fastled-1.4.4/src/fastled/web_compile.py

@@ -0,0 +1,309 @@
+import io
+import os
+import shutil
+import tempfile
+import time
+import zipfile
+from pathlib import Path
+
+import httpx
+
+from fastled.find_good_connection import find_good_connection
+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
+_AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
+
+
+def _sanitize_host(host: str) -> str:
+    if host.startswith("http"):
+        return host
+    is_local_host = "localhost" in host or "127.0.0.1" in host or "0.0.0.0" in host
+    use_https = not is_local_host
+    if use_https:
+        return host if host.startswith("https://") else f"https://{host}"
+    return host if host.startswith("http://") else f"http://{host}"
+
+
+def _banner(msg: str) -> str:
+    """
+    Create a banner for the given message.
+    Example:
+    msg = "Hello, World!"
+    print -> "#################"
+             "# Hello, World! #"
+             "#################"
+    """
+    lines = msg.split("\n")
+    # Find the width of the widest line
+    max_width = max(len(line) for line in lines)
+    width = max_width + 4  # Add 4 for "# " and " #"
+
+    # Create the top border
+    banner = "\n" + "#" * width + "\n"
+
+    # Add each line with proper padding
+    for line in lines:
+        padding = max_width - len(line)
+        banner += f"# {line}{' ' * padding} #\n"
+
+    # Add the bottom border
+    banner += "#" * width + "\n"
+    return f"\n{banner}\n"
+
+
+def _print_banner(msg: str) -> None:
+    print(_banner(msg))
+
+
+def _compile_libfastled(
+    host: str,
+    auth_token: str,
+    build_mode: BuildMode,
+) -> httpx.Response:
+    """Compile the FastLED library separately."""
+    host = _sanitize_host(host)
+    urls = [host]
+    domain = host.split("://")[-1]
+    if ":" not in domain:
+        urls.append(f"{host}:{SERVER_PORT}")
+
+    connection_result = find_good_connection(urls)
+    if connection_result is None:
+        raise ConnectionError(
+            "Connection failed to all endpoints for libfastled compilation"
+        )
+
+    ipv4_stmt = "IPv4" if connection_result.ipv4 else "IPv6"
+    transport = (
+        httpx.HTTPTransport(local_address="0.0.0.0") if connection_result.ipv4 else None
+    )
+
+    with httpx.Client(
+        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,
+        )
+
+        return response
+
+
+def _send_compile_request(
+    host: str,
+    zip_bytes: bytes,
+    auth_token: str,
+    build_mode: BuildMode,
+    profile: bool,
+    no_platformio: bool,
+    allow_libcompile: bool,
+) -> httpx.Response:
+    """Send the compile request to the server and return the response."""
+    host = _sanitize_host(host)
+    urls = [host]
+    domain = host.split("://")[-1]
+    if ":" not in domain:
+        urls.append(f"{host}:{SERVER_PORT}")
+
+    connection_result = find_good_connection(urls)
+    if connection_result is None:
+        raise ConnectionError("Connection failed to all endpoints")
+
+    ipv4_stmt = "IPv4" if connection_result.ipv4 else "IPv6"
+    transport = (
+        httpx.HTTPTransport(local_address="0.0.0.0") if connection_result.ipv4 else None
+    )
+
+    archive_size = len(zip_bytes)
+
+    with httpx.Client(
+        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,
+        )
+
+        return response
+
+
+def _process_compile_response(
+    response: httpx.Response,
+    zip_result: ZipResult,
+    start_time: float,
+) -> CompileResult:
+    """Process the compile response and return the final result."""
+    if response.status_code != 200:
+        json_response = response.json()
+        detail = json_response.get("detail", "Could not compile")
+        return CompileResult(
+            success=False, stdout=detail, hash_value=None, zip_bytes=b""
+        )
+
+    print(f"Response status code: {response}")
+    # Create a temporary directory to extract the zip
+    with tempfile.TemporaryDirectory() as extract_dir:
+        extract_path = Path(extract_dir)
+
+        # Write the response content to a temporary zip file
+        temp_zip = extract_path / "response.zip"
+        temp_zip.write_bytes(response.content)
+
+        # Extract the zip
+        shutil.unpack_archive(temp_zip, extract_path, "zip")
+
+        if zip_result.zip_embedded_bytes:
+            # extract the embedded bytes, which were not sent to the server
+            temp_zip.write_bytes(zip_result.zip_embedded_bytes)
+            shutil.unpack_archive(temp_zip, extract_path, "zip")
+
+        # we don't need the temp zip anymore
+        temp_zip.unlink()
+
+        # Read stdout from out.txt if it exists
+        stdout_file = extract_path / "out.txt"
+        hash_file = extract_path / "hash.txt"
+        stdout = (
+            stdout_file.read_text(encoding="utf-8", errors="replace")
+            if stdout_file.exists()
+            else ""
+        )
+        hash_value = (
+            hash_file.read_text(encoding="utf-8", errors="replace")
+            if hash_file.exists()
+            else None
+        )
+
+        # now rezip the extracted files since we added the embedded json files
+        out_buffer = io.BytesIO()
+        with zipfile.ZipFile(
+            out_buffer, "w", zipfile.ZIP_DEFLATED, compresslevel=9
+        ) as out_zip:
+            for root, _, _files in os.walk(extract_path):
+                for file in _files:
+                    file_path = Path(root) / file
+                    relative_path = file_path.relative_to(extract_path)
+                    out_zip.write(file_path, relative_path)
+
+        diff_time = time.time() - start_time
+        msg = f"Compilation success, took {diff_time:.2f} seconds"
+        _print_banner(msg)
+        return CompileResult(
+            success=True,
+            stdout=stdout,
+            hash_value=hash_value,
+            zip_bytes=out_buffer.getvalue(),
+        )
+
+
+def web_compile(
+    directory: Path | str,
+    host: str | None = None,
+    auth_token: str | None = None,
+    build_mode: BuildMode | None = None,
+    profile: bool = False,
+    no_platformio: bool = False,
+    allow_libcompile: bool = True,
+) -> CompileResult:
+    start_time = time.time()
+    if isinstance(directory, str):
+        directory = Path(directory)
+    host = _sanitize_host(host or DEFAULT_HOST)
+    build_mode = build_mode or BuildMode.QUICK
+    _print_banner(f"Compiling on {host}")
+    auth_token = auth_token or _AUTH_TOKEN
+    if not directory.exists():
+        raise FileNotFoundError(f"Directory not found: {directory}")
+    zip_result: ZipResult | Exception = zip_files(directory, build_mode=build_mode)
+    if isinstance(zip_result, Exception):
+        return CompileResult(
+            success=False, stdout=str(zip_result), hash_value=None, zip_bytes=b""
+        )
+    zip_bytes = zip_result.zip_bytes
+    print(f"Web compiling on {host}...")
+    try:
+        # Step 1: Compile libfastled if requested
+        if allow_libcompile:
+            print("Step 1: Compiling libfastled...")
+            try:
+                libfastled_response = _compile_libfastled(host, auth_token, build_mode)
+                if libfastled_response.status_code != 200:
+                    print(
+                        f"Warning: libfastled compilation failed with status {libfastled_response.status_code}"
+                    )
+                    # Continue with sketch compilation even if libfastled fails
+                else:
+                    print("✅ libfastled compilation successful")
+            except Exception as e:
+                print(f"Warning: libfastled compilation failed: {e}")
+                # Continue with sketch compilation even if libfastled fails
+        else:
+            print("Step 1 (skipped): Compiling libfastled")
+
+        # Step 2: Compile the sketch
+        print("Step 2: Compiling sketch...")
+        response = _send_compile_request(
+            host,
+            zip_bytes,
+            auth_token,
+            build_mode,
+            profile,
+            no_platformio,
+            False,  # allow_libcompile is always False since we handle it manually
+        )
+
+        return _process_compile_response(response, zip_result, start_time)
+
+    except ConnectionError as e:
+        _print_banner(str(e))
+        return CompileResult(
+            success=False,
+            stdout=str(e),
+            hash_value=None,
+            zip_bytes=b"",
+        )
+    except KeyboardInterrupt:
+        print("Keyboard interrupt")
+        raise
+    except httpx.HTTPError as e:
+        print(f"Error: {e}")
+        return CompileResult(
+            success=False, stdout=str(e), hash_value=None, zip_bytes=b""
+        )