fastled 1.4.2__py3-none-any.whl → 1.4.4__py3-none-any.whl

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/__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/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/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/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/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/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/web_compile.py

@@ -1,35 +1,22 @@
-import _thread
 import io
-import json
 import os
 import shutil
 import tempfile
 import time
 import zipfile
-from concurrent.futures import Future, ThreadPoolExecutor, as_completed
-from dataclasses import dataclass
 from pathlib import Path
 
 import httpx
 
+from fastled.find_good_connection import find_good_connection
 from fastled.settings import SERVER_PORT
-from fastled.sketch import get_sketch_files
 from fastled.types import BuildMode, CompileResult
-from fastled.util import hash_file
+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"
-ENABLE_EMBEDDED_DATA = True
-_EXECUTOR = ThreadPoolExecutor(max_workers=8)
-
-
-@dataclass
-class ConnectionResult:
-    host: str
-    success: bool
-    ipv4: bool
 
 
 def _sanitize_host(host: str) -> str:
@@ -42,122 +29,6 @@ def _sanitize_host(host: str) -> str:
     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 _file_info(file_path: Path) -> str:
-    hash_txt = hash_file(file_path)
-    file_size = file_path.stat().st_size
-    json_str = json.dumps({"hash": hash_txt, "size": file_size})
-    return json_str
-
-
-@dataclass
-class ZipResult:
-    zip_bytes: bytes
-    zip_embedded_bytes: bytes | None
-    success: bool
-    error: str | None
-
-
-def zip_files(directory: Path, build_mode: BuildMode) -> ZipResult | Exception:
-    print("Zipping files...")
-    try:
-        files = get_sketch_files(directory)
-        if not files:
-            raise FileNotFoundError(f"No files found in {directory}")
-        for f in files:
-            print(f"Adding file: {f}")
-        # Create in-memory zip file
-        has_embedded_zip = False
-        zip_embedded_buffer = io.BytesIO()
-        zip_buffer = io.BytesIO()
-        with zipfile.ZipFile(
-            zip_embedded_buffer, "w", zipfile.ZIP_DEFLATED, compresslevel=9
-        ) as emebedded_zip_file:
-            with zipfile.ZipFile(
-                zip_buffer, "w", zipfile.ZIP_DEFLATED, compresslevel=9
-            ) as zip_file:
-                for file_path in files:
-                    if "fastled_js" in str(file_path):
-                        # These can be huge, don't send the output files back to the server!
-                        continue
-                    relative_path = file_path.relative_to(directory)
-                    achive_path = str(Path("wasm") / relative_path)
-                    if str(relative_path).startswith("data") and ENABLE_EMBEDDED_DATA:
-                        _file_info_str = _file_info(file_path)
-                        zip_file.writestr(
-                            achive_path + ".embedded.json", _file_info_str
-                        )
-                        emebedded_zip_file.write(file_path, relative_path)
-                        has_embedded_zip = True
-                    else:
-                        zip_file.write(file_path, achive_path)
-                # write build mode into the file as build.txt so that sketches are fingerprinted
-                # based on the build mode. Otherwise the same sketch with different build modes
-                # will have the same fingerprint.
-                zip_file.writestr(
-                    str(Path("wasm") / "build_mode.txt"), build_mode.value
-                )
-        result = ZipResult(
-            zip_bytes=zip_buffer.getvalue(),
-            zip_embedded_bytes=(
-                zip_embedded_buffer.getvalue() if has_embedded_zip else None
-            ),
-            success=True,
-            error=None,
-        )
-        return result
-    except Exception as e:
-        return e
-
-
-def find_good_connection(
-    urls: list[str], filter_out_bad=True, use_ipv6: bool = True
-) -> ConnectionResult | None:
-    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)
-
-    try:
-        # Return first successful result
-        for future in as_completed(futures):
-            result: ConnectionResult = future.result()
-            if result.success or not filter_out_bad:
-                return result
-    finally:
-        # Cancel any remaining futures
-        for future in futures:
-            future.cancel()
-    return None
-
-
 def _banner(msg: str) -> str:
     """
     Create a banner for the given message.
@@ -189,6 +60,179 @@ 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,
@@ -196,6 +240,7 @@ def web_compile(
     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):
@@ -206,125 +251,54 @@ def web_compile(
     auth_token = auth_token or _AUTH_TOKEN
     if not directory.exists():
         raise FileNotFoundError(f"Directory not found: {directory}")
-    zip_result = zip_files(directory, build_mode=build_mode)
+    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
-    archive_size = len(zip_bytes)
     print(f"Web compiling on {host}...")
     try:
-        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:
-            _print_banner("Connection failed to all endpoints")
-            return CompileResult(
-                success=False,
-                stdout="Connection failed",
-                hash_value=None,
-                zip_bytes=b"",
-            )
-
-        ipv4_stmt = "IPv4" if connection_result.ipv4 else "IPv6"
-        transport = (
-            httpx.HTTPTransport(local_address="0.0.0.0")
-            if connection_result.ipv4
-            else None
+        # 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"",
         )
-        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",
-            }
-
-            url = f"{connection_result.host}/{ENDPOINT_COMPILED_WASM}"
-            print(f"Compiling 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,
-            )
-
-            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(),
-                )
     except KeyboardInterrupt:
         print("Keyboard interrupt")
         raise

fastled/zip_files.py

@@ -0,0 +1,76 @@
+import io
+import json
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from fastled.sketch import get_sketch_files
+from fastled.types import BuildMode
+from fastled.util import hash_file
+
+
+def _file_info(file_path: Path) -> str:
+    hash_txt = hash_file(file_path)
+    file_size = file_path.stat().st_size
+    json_str = json.dumps({"hash": hash_txt, "size": file_size})
+    return json_str
+
+
+@dataclass
+class ZipResult:
+    zip_bytes: bytes
+    zip_embedded_bytes: bytes | None
+    success: bool
+    error: str | None
+
+
+def zip_files(directory: Path, build_mode: BuildMode) -> ZipResult | Exception:
+    print("Zipping files...")
+    try:
+        files = get_sketch_files(directory)
+        if not files:
+            raise FileNotFoundError(f"No files found in {directory}")
+        for f in files:
+            print(f"Adding file: {f}")
+        # Create in-memory zip file
+        has_embedded_zip = False
+        zip_embedded_buffer = io.BytesIO()
+        zip_buffer = io.BytesIO()
+        with zipfile.ZipFile(
+            zip_embedded_buffer, "w", zipfile.ZIP_DEFLATED, compresslevel=9
+        ) as emebedded_zip_file:
+            with zipfile.ZipFile(
+                zip_buffer, "w", zipfile.ZIP_DEFLATED, compresslevel=9
+            ) as zip_file:
+                for file_path in files:
+                    if "fastled_js" in str(file_path):
+                        # These can be huge, don't send the output files back to the server!
+                        continue
+                    relative_path = file_path.relative_to(directory)
+                    achive_path = str(Path("wasm") / relative_path)
+                    if str(relative_path).startswith("data"):
+                        _file_info_str = _file_info(file_path)
+                        zip_file.writestr(
+                            achive_path + ".embedded.json", _file_info_str
+                        )
+                        emebedded_zip_file.write(file_path, relative_path)
+                        has_embedded_zip = True
+                    else:
+                        zip_file.write(file_path, achive_path)
+                # write build mode into the file as build.txt so that sketches are fingerprinted
+                # based on the build mode. Otherwise the same sketch with different build modes
+                # will have the same fingerprint.
+                zip_file.writestr(
+                    str(Path("wasm") / "build_mode.txt"), build_mode.value
+                )
+        result = ZipResult(
+            zip_bytes=zip_buffer.getvalue(),
+            zip_embedded_bytes=(
+                zip_embedded_buffer.getvalue() if has_embedded_zip else None
+            ),
+            success=True,
+            error=None,
+        )
+        return result
+    except Exception as e:
+        return e

{fastled-1.4.2.dist-info → fastled-1.4.4.dist-info}/METADATA

@@ -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.2.dist-info → fastled-1.4.4.dist-info}/RECORD

@@ -1,23 +1,24 @@
-fastled/__init__.py,sha256=oQFhIrBU0TbMDfQA1ZmubpZPwDzHmruXFa52H5UFSDE,7300
+fastled/__init__.py,sha256=l4uDkh_YOd24okNfn6eWjtTYaZ0woeYC7khv-vHMmTM,7775
 fastled/__main__.py,sha256=OcKv2ER1_iQAsZzLIUb3C8hRC9L2clNOhCrjpshrlf4,336
-fastled/__version__.py,sha256=l6JsXGE7BZ3G8_6WmM2zKOTzyA6DYGmrSUUebpujEek,372
+fastled/__version__.py,sha256=NeBy2hEASkJ8lb9Yhec88flAXoi8mapEcJBoqi2tBnA,372
 fastled/app.py,sha256=6XOuObi72AUnZXASDOVbcSflr4He0xnIDk5P8nVmVus,6131
 fastled/args.py,sha256=uCMyRIYM8gFE52O12YKUfA-rwJL8Zxwk_hsH3cusSac,3669
 fastled/cli.py,sha256=drgR2AOxVrj3QEz58iiKscYAumbbin2vIV-k91VCOAA,561
 fastled/cli_test.py,sha256=W-1nODZrip_JU6BEbYhxOa4ckxduOsiX8zIoRkTyxv4,550
 fastled/cli_test_interactive.py,sha256=BjNhveZOk5aCffHbcrxPQQjWmAuj4ClVKKcKX5eY6yM,542
-fastled/client_server.py,sha256=n3N-i7EgWtoyb3eR8TaCc3a3Mth9cUcYsyMNICtlJZc,20743
-fastled/compile_server.py,sha256=yQtwLOSKINO1CKD0NWxf-7YQKSatf9sF9RuqaWGOkCs,3038
-fastled/compile_server_impl.py,sha256=9vTGaDQ0W_g9Xsfy0gC3nJEc2g_pnXcF4VO2U3GLOVg,11982
+fastled/client_server.py,sha256=mxRgVtUwsFHGMkCY-rIWUQqiKY6ovUtrWApkhrobrfc,21662
+fastled/compile_server.py,sha256=iGUjteXKp5Dlp7mxAE4eD4s0NWgApRIp4ZjtcAN2iZY,3124
+fastled/compile_server_impl.py,sha256=iCwNCs7YxypUuVPmY4979mOgoH9OiuAJa1a1bmpG1cc,12567
 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/keyboard.py,sha256=UTAsqCn1UMYnB8YDzENiLTj4GeL45tYfEcO7_5fLFEg,3556
 fastled/keyz.py,sha256=LO-8m_7CpNDiZLM-FXhQ30f9gN1bUYz5lOsUPTIbI-c,4020
 fastled/live_client.py,sha256=aDZqSWDMpqNaEsT3u1nrBcdeIOItv-L0Gk2A10difLA,3209
 fastled/open_browser.py,sha256=mwjm65p2ydwmsaar7ooH4mhT5_qH_LZvXUpkRPPJ9eA,4881
 fastled/parse_args.py,sha256=htjap9tWZDJXnJ5upDwcy8EhecJD1uLZwacHR_T5ySs,11518
 fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
-fastled/playwright_browser.py,sha256=jNSIuWYz19t25-p4yj79oQog4l2njwehif9PiTIlLqk,20041
+fastled/playwright_browser.py,sha256=jV0ckpMLoapYSMGABzuR21EYSh_RWa_WgIEm4w3QxTs,23417
 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
@@ -30,7 +31,8 @@ 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=BPrlrW7RMAtnbYUFF3LDn0ORx7aiMOuQkSlYF_gA1o0,11867
+fastled/web_compile.py,sha256=Ql2DBRInZy7dOr1WZiUlhdg1ZVuU1nkbndRWiq7iENQ,10002
+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
@@ -38,9 +40,9 @@ 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.2.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-fastled-1.4.2.dist-info/METADATA,sha256=-p4_m9LetykUugOdeUV-LvpupxDHMvf4ADqGbl339oo,32369
-fastled-1.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fastled-1.4.2.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
-fastled-1.4.2.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
-fastled-1.4.2.dist-info/RECORD,,
+fastled-1.4.4.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.4.4.dist-info/METADATA,sha256=TTvZsjGN8o5yMhMNOhn1_DzlxObwPsTgu0RxeNV4n8A,32369
+fastled-1.4.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fastled-1.4.4.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.4.4.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
+fastled-1.4.4.dist-info/RECORD,,