fastled 1.1.0__py2.py3-none-any.whl → 1.1.3__py2.py3-none-any.whl

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",
@@ -148,9 +159,7 @@ def run_web_compiler(
 
     # now check to see if the hash value is the same as the last hash value
     if last_hash_value is not None and last_hash_value == web_result.hash_value:
-        print(
-            "\nNo significant source code changes detected and data was the same, skipping recompilation."
-        )
+        print("\nSkipping redeploy: No significant changes found.")
         print_results()
         return CompiledResult(
             success=True, fastled_js=str(output_dir), hash_value=web_result.hash_value
@@ -200,7 +209,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 +243,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 +262,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 +368,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/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,35 @@ 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")  # stop git repo updates.
+            if not self.interactive:
+                server_command.append(
+                    "--no-sketch-cache"
+                )  # Remove sketch cache which assumes src is static.
+        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 +170,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 +222,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/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/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.dist-info → fastled-1.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastled
-Version: 1.1.0
+Version: 1.1.3
 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,9 @@ provide shims for most of the common api points.
 
 # Revisions
 
+  * 1.1.3 - Live editing of *.h and *.cpp files is now possible. Sketch cache will be disabled in this mode.
+  * 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.dist-info → fastled-1.1.3.dist-info}/RECORD

@@ -1,18 +1,18 @@
 fastled/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastled/app.py,sha256=N4a-XXteQMTmODxRmEuicUuXKyfP9OS6rGxT36aVAWs,11380
+fastled/app.py,sha256=duSkE31cggy363rFZRHjKIzc0ijCA_TmmPXOLAj-jEM,13560
 fastled/build_mode.py,sha256=joMwsV4K1y_LijT4gEAcjx69RZBoe_KmFmHZdPYbL_4,631
 fastled/check_cpp_syntax.py,sha256=YxRJm7cFPv4bdhL1v_KOkBz8RL86ihayoJYvclr69ms,1024
 fastled/cli.py,sha256=CNR_pQR0sNVPNuv8e_nmm-0PI8sU-eUBUgnWgWkzW9c,237
-fastled/compile_server.py,sha256=_tpHpOgxcizgb9Lis8RVTDsLKLtCaaH3upVH65z0XhA,7994
-fastled/docker_manager.py,sha256=eEc12bmQEER7xf-7ehfYJgQua9cDB1IlLVuuw_9eflI,8934
+fastled/compile_server.py,sha256=QqxTWYmC_Fej-hTNRjfa8qjyGusLY6L858zwTciC9AM,9903
+fastled/docker_manager.py,sha256=WcOKa3EpIPAjICPfTL87CUYuAmX9KYT6L_Hcqbj95eE,9028
 fastled/filewatcher.py,sha256=SHKx9Dnt4EJiT-iPYakdPZBRIL1gsJGN9tY8FJW2myU,5079
 fastled/open_browser.py,sha256=-VhpGmydwLCcXmrDD2esMEdJPZYcoX2Mt73eb88Nna0,1392
 fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
-fastled/web_compile.py,sha256=xHy4ndEy5Xr5-WCINFrgvPgfk7XPm5_MhveiOElJKb0,6372
+fastled/web_compile.py,sha256=rCMClX8yUtZlAzrgFB-r5Pdt7l9TJWhHXe-u99Hmdvw,8257
 fastled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
-fastled-1.1.0.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-fastled-1.1.0.dist-info/METADATA,sha256=C5bl7UjYlsgO2a-Xf6qi9-Dwcg6ctrYWlhZMB86GSSs,5294
-fastled-1.1.0.dist-info/WHEEL,sha256=0VNUDWQJzfRahYI3neAhz2UVbRCtztpN5dPHAGvmGXc,109
-fastled-1.1.0.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
-fastled-1.1.0.dist-info/top_level.txt,sha256=xfG6Z_ol9V5YmBROkZq2QTRwjbS2ouCUxaTJsOwfkOo,14
-fastled-1.1.0.dist-info/RECORD,,
+fastled-1.1.3.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.1.3.dist-info/METADATA,sha256=C2OkZwJd57L96Gauxz_CZKMmk7bmNlv_VhvghbFdMD8,5687
+fastled-1.1.3.dist-info/WHEEL,sha256=0VNUDWQJzfRahYI3neAhz2UVbRCtztpN5dPHAGvmGXc,109
+fastled-1.1.3.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.1.3.dist-info/top_level.txt,sha256=xfG6Z_ol9V5YmBROkZq2QTRwjbS2ouCUxaTJsOwfkOo,14
+fastled-1.1.3.dist-info/RECORD,,