fastled 1.1.0__tar.gz → 1.1.2__tar.gz

{fastled-1.1.0 → fastled-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastled
-Version: 1.1.0
+Version: 1.1.2
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -28,7 +28,6 @@ Compiles an Arduino/Platformio sketch into a wasm binary that can be run directl
 [![Win_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_win.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_win.yml)
 
 
-
 # About
 
 This python app will compile your FastLED style sketches into html/js/wasm output that runs directly in the browser.
@@ -92,6 +91,8 @@ provide shims for most of the common api points.
 
 # Revisions
 
+  * 1.1.2 - `--server` will now volume map fastled src directory if it detects this. This was also implemented on the docker side.
+  * 1.1.1 - `--interactive` is now supported to debug the container. Volume maps and better compatibilty with ipv4/v6 by concurrent connection finding.
   * 1.1.0 - Use `fastled` as the command for the wasm compiler.
   * 1.0.17 - Pulls updates when necessary. Removed dependency on keyring.
   * 1.0.16 - `fastled-wasm` package name has been changed to `fled`

{fastled-1.1.0 → fastled-1.1.2}/README.md

@@ -9,7 +9,6 @@ Compiles an Arduino/Platformio sketch into a wasm binary that can be run directl
 [![Win_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_win.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_win.yml)
 
 
-
 # About
 
 This python app will compile your FastLED style sketches into html/js/wasm output that runs directly in the browser.
@@ -73,6 +72,8 @@ provide shims for most of the common api points.
 
 # Revisions
 
+  * 1.1.2 - `--server` will now volume map fastled src directory if it detects this. This was also implemented on the docker side.
+  * 1.1.1 - `--interactive` is now supported to debug the container. Volume maps and better compatibilty with ipv4/v6 by concurrent connection finding.
   * 1.1.0 - Use `fastled` as the command for the wasm compiler.
   * 1.0.17 - Pulls updates when necessary. Removed dependency on keyring.
   * 1.0.16 - `fastled-wasm` package name has been changed to `fled`

{fastled-1.1.0 → fastled-1.1.2}/examples/wasm/wasm.ino

@@ -14,10 +14,9 @@
 #include "fx/fx_engine.h"
 
 #include "fx/2d/animartrix.hpp"
-#include "platforms/wasm/js.h"
-
 #include "ui.h"
 
+
 #define LED_PIN 3
 #define BRIGHTNESS 96
 #define COLOR_ORDER GRB
@@ -69,6 +68,9 @@ CRGB leds[NUM_LEDS];
 XYMap xyMap = XYMap::constructRectangularGrid(MATRIX_WIDTH, MATRIX_HEIGHT);
 NoisePalette noisePalette = NoisePalette(xyMap);
 
+Title title("FastLED Wasm Demo");
+Description description("This example combines two features of FastLED to produce a remarkable range of effects from a relatively small amount of code.  This example combines FastLED's color palette lookup functions with FastLED's Perlin noise generator, and the combination is extremely powerful.");
+
 Slider brightness("Brightness", 255, 0, 255);
 Checkbox isOff("Off", false);
 Slider speed("Noise - Speed", 15, 1, 50);
@@ -77,8 +79,7 @@ Slider changePalletTime("Noise - Time until next random Palette", 5, 1, 100);
 Slider scale( "Noise - Scale", 20, 1, 100);
 Button changePalette("Noise - Next Palette");
 Button changeFx("Switch between Noise & Animartrix");
-NumberField fxIndex("Animartrix - index", 0, 0, NUM_ANIMATIONS);
-
+NumberField fxIndex("Animartrix - iex", 0, 0, NUM_ANIMATIONS);
 
 Animartrix animartrix(xyMap, POLAR_WAVES);
 FxEngine fxEngine(NUM_LEDS);
@@ -119,11 +120,6 @@ void loop() {
         animartrix.fxSet(fxIndex);
     }
 
-    EVERY_N_MILLISECONDS(1000) {
-        printf("fastled running\r\n");
-        printf("Numberfield: %f\r\n", fxIndex.value());
-    }
-
 
     fxEngine.draw(millis(), leds);
     FastLED.show();

{fastled-1.1.0 → fastled-1.1.2}/pyproject.toml

@@ -19,7 +19,7 @@ dependencies = [
     "filelock",
 ]
 # Change this with the version number bump.
-version = "1.1.0"
+version = "1.1.2"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

{fastled-1.1.0 → fastled-1.1.2}/src/fastled/app.py

@@ -16,7 +16,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from fastled.build_mode import BuildMode, get_build_mode
-from fastled.compile_server import CompileServer
+from fastled.compile_server import CompileServer, looks_like_fastled_repo
 from fastled.docker_manager import DockerManager
 from fastled.filewatcher import FileChangedNotifier
 from fastled.open_browser import open_browser_thread
@@ -81,6 +81,12 @@ def parse_args() -> argparse.Namespace:
         nargs="+",
         help="Additional patterns to exclude from file watching (Not available with --web)",
     )
+    parser.add_argument(
+        "-i",
+        "--interactive",
+        action="store_true",
+        help="Run in interactive mode (Not available with --web)",
+    )
     parser.add_argument(
         "--profile",
         action="store_true",
@@ -97,6 +103,11 @@ def parse_args() -> argparse.Namespace:
     build_mode.add_argument(
         "--release", action="store_true", help="Build in release mode"
     )
+    build_mode.add_argument(
+        "--server",
+        action="store_true",
+        help="Run the server in the current directory, volume mapping fastled if we are in the repo",
+    )
 
     build_mode.add_argument(
         "--force-compile",
@@ -200,7 +211,24 @@ def _try_start_server_or_get_url(args: argparse.Namespace) -> str | CompileServe
             return DEFAULT_URL
 
 
+def _lots_and_lots_of_files(directory: Path) -> bool:
+    count = 0
+    for root, dirs, files in os.walk(directory):
+        count += len(files)
+        if count > 100:
+            return True
+    return False
+
+
 def _looks_like_sketch_directory(directory: Path) -> bool:
+    if looks_like_fastled_repo(directory):
+        print("Directory looks like the FastLED repo")
+        return False
+
+    if _lots_and_lots_of_files(directory):
+        print("Too many files in the directory, bailing out")
+        return False
+
     # walk the path and if there are over 30 files, return False
     # at the root of the directory there should either be an ino file or a src directory
     # or some cpp files
@@ -217,11 +245,10 @@ def _looks_like_sketch_directory(directory: Path) -> bool:
     return False
 
 
-def main() -> int:
-    args = parse_args()
+def run_client(args: argparse.Namespace) -> int:
+    compile_server: CompileServer | None = None
     open_web_browser = not args.just_compile
     profile = args.profile
-
     if not args.force_compile and not _looks_like_sketch_directory(
         Path(args.directory)
     ):
@@ -237,16 +264,16 @@ def main() -> int:
         )
         args.web = True
 
-    compile_server: CompileServer | None = None
     url: str
-
     try:
         try:
             url_or_server: str | CompileServer = _try_start_server_or_get_url(args)
             if isinstance(url_or_server, str):
+                print(f"Found URL: {url_or_server}")
                 url = url_or_server
             else:
                 compile_server = url_or_server
+                print(f"Server started at {compile_server.url()}")
                 url = compile_server.url()
         except KeyboardInterrupt:
             print("\nExiting from first try...")
@@ -343,9 +370,49 @@ def main() -> int:
             browser_proc.kill()
 
 
+def run_server(args: argparse.Namespace) -> int:
+    interactive = args.interactive
+    compile_server = CompileServer(
+        disable_auto_clean=args.no_auto_clean, interactive=interactive
+    )
+    print(f"Server started at {compile_server.url()}")
+    compile_server.start()
+    compile_server.wait_for_startup()
+    try:
+        while True:
+            if not compile_server.proceess_running():
+                print("Server process is not running. Exiting...")
+                return 1
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\nExiting from server...")
+        return 1
+    finally:
+        compile_server.stop()
+    return 0
+
+
+def main() -> int:
+    args = parse_args()
+    target_dir = Path(args.directory)
+    cwd_is_target_dir = target_dir == Path(os.getcwd())
+    force_server = cwd_is_target_dir and looks_like_fastled_repo(target_dir)
+    auto_server = (args.server or args.interactive or cwd_is_target_dir) and (
+        not args.web and not args.just_compile
+    )
+    if auto_server or force_server:
+        print("Running in server only mode.")
+        return run_server(args)
+    else:
+        print("Running in client/server mode.")
+        return run_client(args)
+
+
 if __name__ == "__main__":
     try:
         sys.argv.append("examples/wasm")
+        sys.argv.append("-w")
+        sys.argv.append("localhost")
         sys.exit(main())
     except KeyboardInterrupt:
         print("\nExiting from main...")

{fastled-1.1.0 → fastled-1.1.2}/src/fastled/compile_server.py

@@ -2,6 +2,7 @@ import socket
 import subprocess
 import threading
 import time
+from pathlib import Path
 from typing import Optional
 
 import httpx
@@ -10,10 +11,10 @@ from fastled.docker_manager import DockerManager
 
 _DEFAULT_CONTAINER_NAME = "fastled-wasm-compiler"
 
-_DEFAULT_START_PORT = 9021
+SERVER_PORT = 9021
 
 
-def _find_available_port(start_port: int = _DEFAULT_START_PORT) -> int:
+def find_available_port(start_port: int = SERVER_PORT) -> int:
     """Find an available port starting from the given port."""
     port = start_port
     end_port = start_port + 1000
@@ -26,16 +27,38 @@ def _find_available_port(start_port: int = _DEFAULT_START_PORT) -> int:
                 raise RuntimeError("No available ports found")
 
 
+def looks_like_fastled_repo(directory: Path) -> bool:
+    libprops = directory / "library.properties"
+    if not libprops.exists():
+        return False
+    txt = libprops.read_text()
+    return "FastLED" in txt
+
+
 class CompileServer:
     def __init__(
-        self, container_name=_DEFAULT_CONTAINER_NAME, disable_auto_clean: bool = False
+        self,
+        container_name=_DEFAULT_CONTAINER_NAME,
+        disable_auto_clean: bool = False,
+        interactive: bool = False,
     ) -> None:
+
+        cwd = Path(".").resolve()
+        fastled_src_dir: Path | None = None
+        if looks_like_fastled_repo(cwd):
+            print(
+                "Looks like a FastLED repo, using it as the source directory and mapping it into the server."
+            )
+            fastled_src_dir = cwd / "src"
+
         self.container_name = container_name
         self.disable_auto_clean = disable_auto_clean
         self.docker = DockerManager(container_name=container_name)
         self.running = False
         self.thread: Optional[threading.Thread] = None
         self.running_process: subprocess.Popen | None = None
+        self.fastled_src_dir: Path | None = fastled_src_dir
+        self.interactive = interactive
         self._port = self.start()
 
     def port(self) -> int:
@@ -54,7 +77,9 @@ class CompileServer:
             # use httpx to ping the server
             # if successful, return True
             try:
-                response = httpx.get(f"http://localhost:{self._port}")
+                response = httpx.get(
+                    f"http://localhost:{self._port}", follow_redirects=True
+                )
                 if response.status_code < 400:
                     return True
             except KeyboardInterrupt:
@@ -98,7 +123,7 @@ class CompileServer:
             except Exception as e:
                 print(f"Warning: Failed to remove existing container: {e}")
 
-            print("Ensuring Docker image exists")
+            print("Ensuring Docker image exists at latest version")
             if not self.docker.ensure_image_exists():
                 print("Failed to ensure Docker image exists.")
                 raise RuntimeError("Failed to ensure Docker image exists")
@@ -109,14 +134,31 @@ class CompileServer:
         # subprocess.run(["docker", "rmi", "fastled-wasm"], capture_output=True)
         # print("All clean")
 
-        port = _find_available_port()
+        port = find_available_port()
+        print(f"Found an available port: {port}")
         # server_command = ["python", "/js/run.py", "server", "--allow-shutdown"]
-        server_command = ["python", "/js/run.py", "server"]
+        if self.interactive:
+            server_command = ["/bin/bash"]
+        else:
+            server_command = ["python", "/js/run.py", "server"]
         if self.disable_auto_clean:
             server_command.append("--disable-auto-clean")
         print(f"Started Docker container with command: {server_command}")
         ports = {port: 80}
-        self.running_process = self.docker.run_container(server_command, ports=ports)
+        volumes = None
+        if self.fastled_src_dir:
+            print(
+                f"Mounting FastLED source directory {self.fastled_src_dir} into container /js/fastled/src"
+            )
+            volumes = {
+                str(self.fastled_src_dir): {"bind": "/js/fastled/src", "mode": "rw"}
+            }
+            # no auto-update because the source directory is mapped in.
+            server_command.append("--no-auto-update")
+        self.running_process = self.docker.run_container(
+            server_command, ports=ports, volumes=volumes
+        )
+        print("Compile server starting")
         time.sleep(3)
         if self.running_process.poll() is not None:
             print("Server failed to start")
@@ -124,38 +166,47 @@ class CompileServer:
             raise RuntimeError("Server failed to start")
         self.thread = threading.Thread(target=self._server_loop, daemon=True)
         self.thread.start()
-        print("Compile server started")
+
         return port
 
+    def proceess_running(self) -> bool:
+        if self.running_process is None:
+            return False
+        return self.running_process.poll() is None
+
     def stop(self) -> None:
         print(f"Stopping server on port {self._port}")
         # attempt to send a shutdown signal to the server
-        # httpx.get(f"http://localhost:{self._port}/shutdown", timeout=2)
-        if self.running_process:
-            try:
-                # Stop the Docker container
-                cp: subprocess.CompletedProcess
-                cp = subprocess.run(
-                    ["docker", "stop", self.container_name],
-                    capture_output=True,
-                    text=True,
-                    check=True,
-                )
-                if cp.returncode != 0:
-                    print(f"Failed to stop Docker container: {cp.stderr}")
-
-                cp = subprocess.run(
-                    ["docker", "rm", self.container_name],
-                    capture_output=True,
-                    text=True,
-                    check=True,
-                )
-                if cp.returncode != 0:
-                    print(f"Failed to remove Docker container: {cp.stderr}")
+        try:
+            httpx.get(f"http://localhost:{self._port}/shutdown", timeout=2)
+        # except Exception:
+        except Exception as e:
+            print(f"Failed to send shutdown signal: {e}")
+            pass
+        try:
+            # Stop the Docker container
+            cp: subprocess.CompletedProcess
+            cp = subprocess.run(
+                ["docker", "stop", self.container_name],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            if cp.returncode != 0:
+                print(f"Failed to stop Docker container: {cp.stderr}")
+
+            cp = subprocess.run(
+                ["docker", "rm", self.container_name],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            if cp.returncode != 0:
+                print(f"Failed to remove Docker container: {cp.stderr}")
 
-                # Close the stdout pipe
-                if self.running_process.stdout:
-                    self.running_process.stdout.close()
+            # Close the stdout pipe
+            if self.running_process and self.running_process.stdout:
+                self.running_process.stdout.close()
 
                 # Wait for the process to fully terminate with a timeout
                 self.running_process.wait(timeout=10)
@@ -167,17 +218,19 @@ class CompileServer:
                         f"Server stopped with return code {self.running_process.returncode}"
                     )
 
-            except subprocess.TimeoutExpired:
-                # Force kill if it doesn't stop gracefully
+        except subprocess.TimeoutExpired:
+            # Force kill if it doesn't stop gracefully
+            if self.running_process:
                 self.running_process.kill()
                 self.running_process.wait()
-            except KeyboardInterrupt:
+        except KeyboardInterrupt:
+            if self.running_process:
                 self.running_process.kill()
                 self.running_process.wait()
-            except Exception as e:
-                print(f"Error stopping Docker container: {e}")
-            finally:
-                self.running_process = None
+        except Exception as e:
+            print(f"Error stopping Docker container: {e}")
+        finally:
+            self.running_process = None
         # Signal the server thread to stop
         self.running = False
         if self.thread:

{fastled-1.1.0 → fastled-1.1.2}/src/fastled/docker_manager.py

@@ -210,15 +210,15 @@ class DockerManager:
     def run_container(
         self,
         cmd: list[str],
-        volumes: dict[str, str] | None = None,
+        volumes: dict[str, dict[str, str]] | None = None,
         ports: dict[int, int] | None = None,
     ) -> subprocess.Popen:
         """Run the Docker container with the specified volume.
 
         Args:
-            volume_path: Path to the volume to mount
-            base_name: Base name for the mounted volume
-            build_mode: Build mode (DEBUG, QUICK, or RELEASE)
+            cmd: Command to run in the container
+            volumes: Dict mapping host paths to dicts with 'bind' and 'mode' keys
+            ports: Dict mapping host ports to container ports
         """
         volumes = volumes or {}
         ports = ports or {}
@@ -237,8 +237,10 @@ class DockerManager:
             for host_port, container_port in ports.items():
                 docker_command.extend(["-p", f"{host_port}:{container_port}"])
         if volumes:
-            for host_path, container_path in volumes.items():
-                docker_command.extend(["-v", f"{host_path}:{container_path}"])
+            for host_path, mount_spec in volumes.items():
+                docker_command.extend(
+                    ["-v", f"{host_path}:{mount_spec['bind']}:{mount_spec['mode']}"]
+                )
 
         docker_command.extend(
             [

{fastled-1.1.0 → fastled-1.1.2}/src/fastled/web_compile.py

@@ -1,173 +1,220 @@
-import shutil
-import tempfile
-from dataclasses import dataclass
-from pathlib import Path
-
-import httpx
-
-from fastled.build_mode import BuildMode
-
-DEFAULT_HOST = "https://fastled.onrender.com"
-ENDPOINT_COMPILED_WASM = "compile/wasm"
-_TIMEOUT = 60 * 4  # 2 mins timeout
-_AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
-
-
-@dataclass
-class WebCompileResult:
-    success: bool
-    stdout: str
-    hash_value: str | None
-    zip_bytes: bytes
-
-    def __bool__(self) -> bool:
-        return self.success
-
-
-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}"
-
-
-_CONNECTION_ERROR_MAP: dict[str, bool] = {}
-
-
-def web_compile(
-    directory: Path,
-    host: str | None = None,
-    auth_token: str | None = None,
-    build_mode: BuildMode | None = None,
-    profile: bool = False,
-) -> WebCompileResult:
-    host = _sanitize_host(host or DEFAULT_HOST)
-    auth_token = auth_token or _AUTH_TOKEN
-    # zip up the files
-    print("Zipping files...")
-
-    # Create a temporary zip file
-    with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp_zip:
-        # Create temporary directory for organizing files
-        with tempfile.TemporaryDirectory() as temp_dir:
-            # Create wasm subdirectory
-            wasm_dir = Path(temp_dir) / "wasm"
-
-            # Copy all files from source to wasm subdirectory, excluding fastled_js
-            def ignore_fastled_js(dir: str, files: list[str]) -> list[str]:
-                if "fastled_js" in dir:
-                    return files
-                if dir.startswith("."):
-                    return files
-                return []
-
-            shutil.copytree(directory, wasm_dir, ignore=ignore_fastled_js)
-            # Create zip archive from the temp directory
-            shutil.make_archive(tmp_zip.name[:-4], "zip", temp_dir)
-
-    print(f"Web compiling on {host}...")
-
-    try:
-        with open(tmp_zip.name, "rb") as zip_file:
-            files = {"file": ("wasm.zip", zip_file, "application/x-zip-compressed")}
-
-            tested = host in _CONNECTION_ERROR_MAP
-            if not tested:
-                test_url = f"{host}/healthz"
-                print(f"Testing connection to {test_url}")
-                timeout = 10
-                with httpx.Client(
-                    transport=httpx.HTTPTransport(local_address="0.0.0.0"),
-                    timeout=timeout,
-                ) as test_client:
-                    test_response = test_client.get(test_url, timeout=timeout)
-                    if test_response.status_code != 200:
-                        print(f"Connection to {test_url} failed")
-                        _CONNECTION_ERROR_MAP[host] = True
-                        return WebCompileResult(
-                            success=False,
-                            stdout="Connection failed",
-                            hash_value=None,
-                            zip_bytes=b"",
-                        )
-                    _CONNECTION_ERROR_MAP[host] = False
-
-            ok = not _CONNECTION_ERROR_MAP[host]
-            if not ok:
-                return WebCompileResult(
-                    success=False,
-                    stdout="Connection failed",
-                    hash_value=None,
-                    zip_bytes=b"",
-                )
-            print(f"Connection to {host} successful")
-            with httpx.Client(
-                transport=httpx.HTTPTransport(local_address="0.0.0.0"),  # forces IPv4
-                timeout=_TIMEOUT,
-            ) as client:
-                url = f"{host}/{ENDPOINT_COMPILED_WASM}"
-                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",
-                }
-                print(f"Compiling on {url}")
-                response = client.post(
-                    url,
-                    files=files,
-                    headers=headers,
-                    timeout=_TIMEOUT,
-                )
-
-                if response.status_code != 200:
-                    json_response = response.json()
-                    detail = json_response.get("detail", "Could not compile")
-                    return WebCompileResult(
-                        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")
-
-                    # 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() if stdout_file.exists() else ""
-                    hash_value = hash_file.read_text() if hash_file.exists() else None
-
-                    return WebCompileResult(
-                        success=True,
-                        stdout=stdout,
-                        hash_value=hash_value,
-                        zip_bytes=response.content,
-                    )
-    except KeyboardInterrupt:
-        print("Keyboard interrupt")
-        raise
-    except httpx.HTTPError as e:
-        print(f"Error: {e}")
-        return WebCompileResult(
-            success=False, stdout=str(e), hash_value=None, zip_bytes=b""
-        )
-    finally:
-        try:
-            Path(tmp_zip.name).unlink()
-        except PermissionError:
-            print("Warning: Could not delete temporary zip file")
+import shutil
+import tempfile
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+
+from fastled.build_mode import BuildMode
+from fastled.compile_server import SERVER_PORT
+
+DEFAULT_HOST = "https://fastled.onrender.com"
+ENDPOINT_COMPILED_WASM = "compile/wasm"
+_TIMEOUT = 60 * 4  # 2 mins timeout
+_AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
+
+
+@dataclass
+class TestConnectionResult:
+    host: str
+    success: bool
+    ipv4: bool
+
+
+@dataclass
+class WebCompileResult:
+    success: bool
+    stdout: str
+    hash_value: str | None
+    zip_bytes: bytes
+
+    def __bool__(self) -> bool:
+        return self.success
+
+
+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}"
+
+
+_CONNECTION_ERROR_MAP: dict[str, TestConnectionResult] = {}
+
+
+def _test_connection(host: str, use_ipv4: bool) -> TestConnectionResult:
+    key = f"{host}-{use_ipv4}"
+    maybe_result: TestConnectionResult | None = _CONNECTION_ERROR_MAP.get(key)
+    if maybe_result is not None:
+        return maybe_result
+    transport = httpx.HTTPTransport(local_address="0.0.0.0") if use_ipv4 else None
+    try:
+        with httpx.Client(
+            timeout=_TIMEOUT,
+            transport=transport,
+        ) as test_client:
+            test_response = test_client.get(
+                f"{host}/healthz", timeout=_TIMEOUT, follow_redirects=True
+            )
+            result = TestConnectionResult(
+                host, test_response.status_code == 200, use_ipv4
+            )
+            _CONNECTION_ERROR_MAP[key] = result
+    except Exception:
+        result = TestConnectionResult(host, False, use_ipv4)
+        _CONNECTION_ERROR_MAP[key] = result
+    return result
+
+
+def web_compile(
+    directory: Path,
+    host: str | None = None,
+    auth_token: str | None = None,
+    build_mode: BuildMode | None = None,
+    profile: bool = False,
+) -> WebCompileResult:
+    host = _sanitize_host(host or DEFAULT_HOST)
+    print("Compiling on", host)
+    auth_token = auth_token or _AUTH_TOKEN
+    # zip up the files
+    print("Zipping files...")
+
+    # Create a temporary zip file
+    with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp_zip:
+        # Create temporary directory for organizing files
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create wasm subdirectory
+            wasm_dir = Path(temp_dir) / "wasm"
+
+            # Copy all files from source to wasm subdirectory, excluding fastled_js
+            def ignore_fastled_js(dir: str, files: list[str]) -> list[str]:
+                if "fastled_js" in dir:
+                    return files
+                if dir.startswith("."):
+                    return files
+                return []
+
+            shutil.copytree(directory, wasm_dir, ignore=ignore_fastled_js)
+            # Create zip archive from the temp directory
+            shutil.make_archive(tmp_zip.name[:-4], "zip", temp_dir)
+
+    print(f"Web compiling on {host}...")
+
+    try:
+        with open(tmp_zip.name, "rb") as zip_file:
+            files = {"file": ("wasm.zip", zip_file, "application/x-zip-compressed")}
+            urls = [host]
+            domain = host.split("://")[-1]
+            if ":" not in domain:
+                urls.append(f"{host}:{SERVER_PORT}")
+            test_connection_result: TestConnectionResult | None = None
+
+            with ThreadPoolExecutor(max_workers=len(urls)) as executor:
+                futures: list = []
+                ip_versions = [True, False] if "localhost" not in host else [True]
+                for ipv4 in ip_versions:
+                    for url in urls:
+                        f = executor.submit(_test_connection, url, ipv4)
+                        futures.append(f)
+
+                succeeded = False
+                for future in as_completed(futures):
+                    result: TestConnectionResult = future.result()
+
+                    if result.success:
+                        print(f"Connection successful to {result.host}")
+                        succeeded = True
+                        # host = test_url
+                        test_connection_result = result
+                        break
+                    else:
+                        print(f"Ignoring {result.host} due to connection failure")
+
+                if not succeeded:
+                    print("Connection failed to all endpoints")
+                    return WebCompileResult(
+                        success=False,
+                        stdout="Connection failed",
+                        hash_value=None,
+                        zip_bytes=b"",
+                    )
+            assert test_connection_result is not None
+            ipv4_stmt = "IPv4" if test_connection_result.ipv4 else "IPv6"
+            transport = (
+                httpx.HTTPTransport(local_address="0.0.0.0")
+                if test_connection_result.ipv4
+                else None
+            )
+            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",
+                }
+
+                url = f"{test_connection_result.host}/{ENDPOINT_COMPILED_WASM}"
+                print(f"Compiling on {url} via {ipv4_stmt}")
+                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 WebCompileResult(
+                        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")
+
+                    # 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() if stdout_file.exists() else ""
+                    hash_value = hash_file.read_text() if hash_file.exists() else None
+
+                    return WebCompileResult(
+                        success=True,
+                        stdout=stdout,
+                        hash_value=hash_value,
+                        zip_bytes=response.content,
+                    )
+    except KeyboardInterrupt:
+        print("Keyboard interrupt")
+        raise
+    except httpx.HTTPError as e:
+        print(f"Error: {e}")
+        return WebCompileResult(
+            success=False, stdout=str(e), hash_value=None, zip_bytes=b""
+        )
+    finally:
+        try:
+            Path(tmp_zip.name).unlink()
+        except PermissionError:
+            print("Warning: Could not delete temporary zip file")

{fastled-1.1.0 → fastled-1.1.2}/src/fastled.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastled
-Version: 1.1.0
+Version: 1.1.2
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -28,7 +28,6 @@ Compiles an Arduino/Platformio sketch into a wasm binary that can be run directl
 [![Win_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_win.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_win.yml)
 
 
-
 # About
 
 This python app will compile your FastLED style sketches into html/js/wasm output that runs directly in the browser.
@@ -92,6 +91,8 @@ provide shims for most of the common api points.
 
 # Revisions
 
+  * 1.1.2 - `--server` will now volume map fastled src directory if it detects this. This was also implemented on the docker side.
+  * 1.1.1 - `--interactive` is now supported to debug the container. Volume maps and better compatibilty with ipv4/v6 by concurrent connection finding.
   * 1.1.0 - Use `fastled` as the command for the wasm compiler.
   * 1.0.17 - Pulls updates when necessary. Removed dependency on keyring.
   * 1.0.16 - `fastled-wasm` package name has been changed to `fled`

{fastled-1.1.0 → fastled-1.1.2}/test

@@ -4,6 +4,6 @@ set -e
 
 # Can't run in parralel because of the shared docker
 # instance.
-uv run pytest tests -v
+uv run pytest tests -v "$@"
 # uv run pytest -n auto tests -v
 

{fastled-1.1.0 → fastled-1.1.2}/tests/test_compile_server.py

@@ -36,7 +36,7 @@ class WebCompilerTester(unittest.TestCase):
         # Verify server stopped
         self.assertFalse(server.running, "Server did not stop")
         self.assertIsNone(server.running_process, "Server process not cleared")
-        self.assertTrue(result.success, "Compilation failed")
+        self.assertTrue(result.success, f"Compilation failed: {result.stdout}")
 
 
 if __name__ == "__main__":

{fastled-1.1.0 → fastled-1.1.2}/tests/test_webcompile.py

@@ -23,7 +23,7 @@ class WebCompileTester(unittest.TestCase):
         print(f"Time taken: {diff:.2f} seconds")
 
         # Verify we got a successful result
-        self.assertTrue(result.success)
+        self.assertTrue(result.success, f"Compilation failed: {result.stdout}")
 
         # Verify we got actual WASM data back
         self.assertTrue(len(result.zip_bytes) > 0)