fastled 1.0.11__py2.py3-none-any.whl → 1.0.15__py2.py3-none-any.whl

fastled/__init__.py

@@ -1,3 +1,3 @@
 """FastLED Wasm Compiler package."""
 
-__version__ = "1.0.11"
+__version__ = "1.0.15"

fastled/app.py

@@ -20,8 +20,8 @@ from fastled.docker_manager import DockerManager
 from fastled.filewatcher import FileWatcherProcess
 from fastled.keyboard import SpaceBarWatcher
 from fastled.open_browser import open_browser_thread
-from fastled.sketch import looks_like_sketch_directory
-from fastled.web_compile import web_compile
+from fastled.sketch import looks_like_fastled_repo, looks_like_sketch_directory
+from fastled.web_compile import ConnectionResult, find_good_connection, web_compile
 
 machine = platform.machine().lower()
 IS_ARM: bool = "arm" in machine or "aarch64" in machine
@@ -93,8 +93,9 @@ def parse_args() -> argparse.Namespace:
     )
     build_mode.add_argument(
         "--localhost",
+        "--local",
         action="store_true",
-        help="Use localhost for web compilation from an instance of fastled --server",
+        help="Use localhost for web compilation from an instance of fastled --server, creating it if necessary",
     )
     build_mode.add_argument(
         "--server",
@@ -108,13 +109,20 @@ def parse_args() -> argparse.Namespace:
         help="Skips the test to see if the current directory is a valid FastLED sketch directory",
     )
 
+    cwd_is_fastled = looks_like_fastled_repo(Path(os.getcwd()))
+
     args = parser.parse_args()
+    if not cwd_is_fastled and not args.localhost and not args.web and not args.server:
+        print(f"Using web compiler at {DEFAULT_URL}")
+        args.web = DEFAULT_URL
+    if cwd_is_fastled and not args.web:
+        print("Forcing --local mode because we are in the FastLED repo")
+        args.localhost = True
     if args.localhost:
         args.web = "localhost"
-    if args.web is not None:
-        args.web = args.web if args.web == "" else args.web
-    if args.server and args.web:
-        parser.error("--server and --web are mutually exclusive")
+    if args.interactive and not args.server:
+        print("--interactive forces --server mode")
+        args.server = True
     if args.directory is None and not args.server:
         # does current directory look like a sketch?
         maybe_sketch_dir = Path(os.getcwd())
@@ -125,6 +133,7 @@ def parse_args() -> argparse.Namespace:
                 "\nYou either need to specify a sketch directory or run in --server mode."
             )
             sys.exit(1)
+
     return args
 
 
@@ -188,7 +197,20 @@ def run_web_compiler(
 
 
 def _try_start_server_or_get_url(args: argparse.Namespace) -> str | CompileServer:
-    if args.web:
+    is_local_host = "localhost" in args.web or "127.0.0.1" in args.web or args.localhost
+
+    # test to see if there is already a local host server
+    local_host_needs_server = False
+    if is_local_host:
+        addr = "localhost" if args.localhost else args.web
+        result: ConnectionResult | None = find_good_connection([addr])
+        if result is not None:
+            print(f"Found local server at {result.host}")
+            return result.host
+        else:
+            local_host_needs_server = True
+
+    if not local_host_needs_server and args.web:
         if isinstance(args.web, str):
             return args.web
         if isinstance(args.web, bool):
@@ -196,6 +218,7 @@ def _try_start_server_or_get_url(args: argparse.Namespace) -> str | CompileServe
         return args.web
     else:
         try:
+            print("No local server found, starting one...")
             compile_server = CompileServer()
             print("Waiting for the local compiler to start...")
             if not compile_server.wait_for_startup():
@@ -211,7 +234,7 @@ def _try_start_server_or_get_url(args: argparse.Namespace) -> str | CompileServe
 
 def run_client(args: argparse.Namespace) -> int:
     compile_server: CompileServer | None = None
-    open_web_browser = not args.just_compile
+    open_web_browser = not args.just_compile and not args.interactive
     profile = args.profile
     if not args.force_compile and not looks_like_sketch_directory(Path(args.directory)):
         print(
@@ -398,8 +421,9 @@ def main() -> int:
 
 if __name__ == "__main__":
     try:
-        os.chdir("../fastled")
+        # os.chdir("../fastled")
         sys.argv.append("examples/SdCard")
+        sys.argv.append("--localhost")
         sys.exit(main())
     except KeyboardInterrupt:
         print("\nExiting from main...")

fastled/compile_server.py

@@ -12,6 +12,8 @@ _DEFAULT_CONTAINER_NAME = "fastled-wasm-compiler"
 
 SERVER_PORT = 9021
 
+SERVER_OPTIONS = ["--allow-shutdown", "--no-auto-update"]
+
 
 def find_available_port(start_port: int = SERVER_PORT) -> int:
     """Find an available port starting from the given port."""
@@ -48,6 +50,12 @@ class CompileServer:
         self.fastled_src_dir: Path | None = fastled_src_dir
         self.interactive = interactive
         self._port = self._start()
+        # fancy print
+        if not interactive:
+            msg = f"# FastLED Compile Server started at {self.url()} #"
+            print("\n" + "#" * len(msg))
+            print(msg)
+            print("#" * len(msg) + "\n")
 
     def using_fastled_src_dir_volume(self) -> bool:
         return self.fastled_src_dir is not None
@@ -124,8 +132,9 @@ class CompileServer:
         if self.interactive:
             server_command = ["/bin/bash"]
         else:
-            server_command = ["python", "/js/run.py", "server", "--allow-shutdown"]
-        print(f"Started Docker container with command: {server_command}")
+            server_command = ["python", "/js/run.py", "server"] + SERVER_OPTIONS
+        server_cmd_str = subprocess.list2cmdline(server_command)
+        print(f"Started Docker container with command: {server_cmd_str}")
         ports = {port: 80}
         volumes = None
         if self.fastled_src_dir:
@@ -135,10 +144,6 @@ class CompileServer:
             volumes = {
                 str(self.fastled_src_dir): {"bind": "/host/fastled/src", "mode": "ro"}
             }
-            if not self.interactive:
-                # no auto-update because the source directory is mapped in.
-                # This should be automatic now.
-                server_command.append("--no-auto-update")  # stop git repo updates.
         self.running_process = self.docker.run_container(
             server_command, ports=ports, volumes=volumes, tty=self.interactive
         )

fastled/keyboard.py

@@ -1,89 +1,91 @@
-import os
-import select
-import sys
-import time
-from multiprocessing import Process, Queue
-from queue import Empty
-
-
-class SpaceBarWatcher:
-    def __init__(self) -> None:
-        self.queue: Queue = Queue()
-        self.queue_cancel: Queue = Queue()
-        self.process = Process(target=self._watch_for_space)
-        self.process.start()
-
-    def _watch_for_space(self) -> None:
-        # Set stdin to non-blocking mode
-        fd = sys.stdin.fileno()
-        if os.name != "nt":  # Unix-like systems
-            import termios
-            import tty
-
-            old_settings = termios.tcgetattr(fd)  # type: ignore
-            try:
-                tty.setraw(fd)  # type: ignore
-                while True:
-                    # Check for cancel signal
-                    try:
-                        self.queue_cancel.get(timeout=0.1)
-                        break
-                    except Empty:
-                        pass
-
-                    # Check if there's input ready
-                    if select.select([sys.stdin], [], [], 0.1)[0]:
-                        char = sys.stdin.read(1)
-                        if char == " ":
-                            self.queue.put(ord(" "))
-            finally:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)  # type: ignore
-        else:  # Windows
-            import msvcrt
-
-            while True:
-                # Check for cancel signal
-                try:
-                    self.queue_cancel.get(timeout=0.1)
-                    break
-                except Empty:
-                    pass
-
-                # Check if there's input ready
-                if msvcrt.kbhit():
-                    char = msvcrt.getch().decode()
-                    if char == " ":
-                        self.queue.put(ord(" "))
-
-    def space_bar_pressed(self) -> bool:
-        found = False
-        while not self.queue.empty():
-            key = self.queue.get()
-            if key == ord(" "):
-                found = True
-        return found
-
-    def stop(self) -> None:
-        self.queue_cancel.put(True)
-        self.process.terminate()
-        self.process.join()
-        self.queue.close()
-        self.queue.join_thread()
-
-
-def main() -> None:
-    watcher = SpaceBarWatcher()
-    try:
-        while True:
-            if watcher.space_bar_pressed():
-                break
-            time.sleep(1)
-    finally:
-        watcher.stop()
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except KeyboardInterrupt:
-        print("Keyboard interrupt detected.")
+import os
+import select
+import sys
+import time
+from multiprocessing import Process, Queue
+from queue import Empty
+
+
+class SpaceBarWatcher:
+    def __init__(self) -> None:
+        self.queue: Queue = Queue()
+        self.queue_cancel: Queue = Queue()
+        self.process = Process(target=self._watch_for_space)
+        self.process.start()
+
+    def _watch_for_space(self) -> None:
+        # Set stdin to non-blocking mode
+        fd = sys.stdin.fileno()
+
+        if os.name == "nt":  # Windows
+            import msvcrt
+
+            while True:
+                # Check for cancel signal
+                try:
+                    self.queue_cancel.get(timeout=0.1)
+                    break
+                except Empty:
+                    pass
+
+                # Check if there's input ready
+                if msvcrt.kbhit():  # type: ignore
+                    char = msvcrt.getch().decode()  # type: ignore
+                    if char == " ":
+                        self.queue.put(ord(" "))
+
+        else:  # Unix-like systems
+            import termios
+            import tty
+
+            old_settings = termios.tcgetattr(fd)  # type: ignore
+            try:
+                tty.setraw(fd)  # type: ignore
+                while True:
+                    # Check for cancel signal
+                    try:
+                        self.queue_cancel.get(timeout=0.1)
+                        break
+                    except Empty:
+                        pass
+
+                    # Check if there's input ready
+                    if select.select([sys.stdin], [], [], 0.1)[0]:
+                        char = sys.stdin.read(1)
+                        if char == " ":
+                            self.queue.put(ord(" "))
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)  # type: ignore
+
+    def space_bar_pressed(self) -> bool:
+        found = False
+        while not self.queue.empty():
+            key = self.queue.get()
+            if key == ord(" "):
+                found = True
+        return found
+
+    def stop(self) -> None:
+        self.queue_cancel.put(True)
+        self.process.terminate()
+        self.process.join()
+        self.queue.close()
+        self.queue.join_thread()
+
+
+def main() -> None:
+    watcher = SpaceBarWatcher()
+    try:
+        while True:
+            if watcher.space_bar_pressed():
+                break
+            time.sleep(1)
+    finally:
+        watcher.stop()
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("Keyboard interrupt detected.")

fastled/web_compile.py

@@ -1,277 +1,291 @@
-import io
-import json
-import os
-import shutil
-import tempfile
-import zipfile
-from concurrent.futures import ProcessPoolExecutor, 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
-from fastled.sketch import get_sketch_files
-from fastled.util import hash_file
-
-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 = ProcessPoolExecutor(max_workers=8)
-
-
-@dataclass
-class ConnectionResult:
-    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}"
-
-
-def _test_connection(host: str, use_ipv4: bool) -> ConnectionResult:
-    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=3, follow_redirects=True
-            )
-            result = ConnectionResult(host, test_response.status_code == 200, 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) -> 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:
-                    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)
-        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 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
-
-    if not directory.exists():
-        raise FileNotFoundError(f"Directory not found: {directory}")
-
-    zip_result = zip_files(directory)
-
-    if isinstance(zip_result, Exception):
-        return WebCompileResult(
-            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:
-
-        files = {"file": ("wasm.zip", zip_bytes, "application/x-zip-compressed")}
-        urls = [host]
-        domain = host.split("://")[-1]
-        if ":" not in domain:
-            urls.append(f"{host}:{SERVER_PORT}")
-        test_connection_result: ConnectionResult | None = None
-
-        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: ConnectionResult = 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}. Zip size: {archive_size} bytes")
-            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")
-
-                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() if stdout_file.exists() else ""
-                hash_value = hash_file.read_text() 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)
-
-                return WebCompileResult(
-                    success=True,
-                    stdout=stdout,
-                    hash_value=hash_value,
-                    zip_bytes=out_buffer.getvalue(),
-                )
-    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""
-        )
+import io
+import json
+import os
+import shutil
+import tempfile
+import zipfile
+from concurrent.futures import Future, ProcessPoolExecutor, 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
+from fastled.sketch import get_sketch_files
+from fastled.util import hash_file
+
+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 = ProcessPoolExecutor(max_workers=8)
+
+
+@dataclass
+class ConnectionResult:
+    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}"
+
+
+def _test_connection(host: str, use_ipv4: bool) -> ConnectionResult:
+    # Function static cache
+    connection_cache = _test_connection.__dict__.setdefault("_CONNECTION_CACHE", {})
+    key = f"{host}_{use_ipv4}"
+    cached_result = connection_cache.get(key)
+    if cached_result is not None:
+        return cached_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=3, follow_redirects=True
+            )
+            result = ConnectionResult(host, test_response.status_code == 200, use_ipv4)
+    except Exception:
+        result = ConnectionResult(host, False, use_ipv4)
+    connection_cache[key] = result
+    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:
+                    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:
+            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 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)
+    build_mode = build_mode or BuildMode.QUICK
+    print("Compiling on", host)
+    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)
+    if isinstance(zip_result, Exception):
+        return WebCompileResult(
+            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:
+        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("Connection failed to all endpoints")
+            return WebCompileResult(
+                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
+        )
+        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"{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 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")
+
+                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() if stdout_file.exists() else ""
+                hash_value = hash_file.read_text() 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)
+
+                return WebCompileResult(
+                    success=True,
+                    stdout=stdout,
+                    hash_value=hash_value,
+                    zip_bytes=out_buffer.getvalue(),
+                )
+    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""
+        )

fastled-1.0.15.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.1
+Name: fastled
+Version: 1.0.15
+Summary: FastLED Wasm Compiler
+Home-page: https://github.com/zackees/fastled-wasm
+Maintainer: Zachary Vorhies
+License: BSD 3-Clause License
+Keywords: template-python-cmd
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: docker
+Requires-Dist: httpx
+Requires-Dist: watchdog
+Requires-Dist: livereload
+Requires-Dist: download
+Requires-Dist: filelock
+
+# FastLED Wasm compiler
+
+Compiles an Arduino/Platformio sketch into a wasm binary that can be run directly in the web browser.
+
+
+[![Linting](https://github.com/zackees/fastled-wasm/actions/workflows/lint.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/lint.yml)
+[![Build and Push Multi Docker Image](https://github.com/zackees/fastled-wasm/actions/workflows/build_multi_docker_image.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/build_multi_docker_image.yml)
+[![MacOS_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_macos.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_macos.yml)
+[![Ubuntu_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_ubuntu.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_ubuntu.yml)
+[![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.
+
+Compile times are extremely fast, thanks to aggressive object caching for C++ and sketch fingerprinting with a zip file cache. Recompilation of sketch files with minimal changes will occure in less than a second.
+
+By default the web compiler will always be used unless that user specifies `--local`, in which case this compiler will invoke docker to bring in a runtime necessary to run the compiler toolchain.
+
+The local compiler will be much faster than the web version in most circumstances after the first compile. The web compiler
+has the advantage that as a persistant service the compile cache will remain much more up to date.
+
+
+https://github.com/user-attachments/assets/64ae0e6c-5f8b-4830-ab87-dcc25bc61218
+
+# Demo
+
+https://zackees.github.io/fastled-wasm/
+
+
+
+# Install
+
+```bash
+pip install fastled
+```
+
+**Note that you may need to install x86 docker emulation on Mac-m1 and later, as this is an x86 only image at the prsent.**
+
+# Use
+
+Change to the directory where the sketch lives and run, will run the compilation
+on the web compiler.
+
+```bash
+cd <SKETCH-DIRECTORY>
+fastled
+```
+
+Or if you have docker you can run a server automatically.
+
+```bash
+cd <SKETCH-DIRECTORY>
+fastled --local
+```
+
+You can also spawn a server in one process and then access it in another, like this:
+
+```bash
+fastled --server
+# now launch the client
+fastled examples/wasm --local
+```
+
+After compilation a web browser windows will pop up. Changes to the sketch will automatically trigger a recompilation.
+
+# Hot reload by default
+
+Once launched, the compiler will remain open, listening to changes and recompiling as necessary and hot-reloading the sketch into the current browser.
+
+This style of development should be familiar to those doing web development.
+
+# Hot Reload for working with the FastLED repo
+
+If you launch `fastled` in the FastLED repo then this tool will automatically detect this and map the src directory into the
+host container. Whenever there are changes in the source code from the mapped directory, then these will be re-compiled
+on the next change or if you hit the space bar when prompted. Unlike a sketch folder, a re-compile on the FastLED src
+can be much longer, for example if you modify a header file.
+
+# Data
+
+Huge blobs of data like video will absolutely kill the compile performance as these blobs would normally have to be shuffled
+back and forth. Therefore a special directory `data/` is implicitly used to hold this blob data. Any data in this directory
+will be replaced with a stub containing the size and hash of the file during upload. On download these stubs are swapped back
+with their originals.
+
+The wasm compiler will also recongize all files in the `data/` directory and generate a `files.json` manifest and can be used
+in your wasm sketch using an emulated SD card system mounted at `/data/` on the SD Card. In order to increase load speed, these
+files will be asynchroniously streamed into the running sketch instance during runtime. The only caveat here is that although these files will be available during the setup() phase of the sketch, they will not be fully hydrated, so if you do a seek(end) of these files the results are undefined.
+
+For an example of how to use this see `examples/SdCard` which is fully wasm compatible.
+
+# Compile Speed
+
+The compile speeds for this compiler have been optimized pretty much to the max. There are three compile settings available to the user. The default is `--quick`. Aggressive optimizations are done with `--release` which will aggressively optimize for size. The speed difference between `--release` and `--quick` seems negligable. But `--release` will produce a ~1/3 smaller binary. There is also `--debug`, which will include symbols necessary for debugging and getting the C++ function symbols working correctly in the browser during step through debugging. It works better than expected, but don't expect to have gdb or msvc debugger level of debugging experience.
+
+We use `ccache` to cache object files. This seems actually help a lot and is better than platformio's method of tracking what needs to be rebuilt. This works as a two tier cache system. What Platformio misses will be covered by ccache's more advanced file changing system.
+
+The compilation to wasm will happen under a lock. Removing this lock requires removing the platformio toolchain as the compiler backend which enforces it's own internal lock preventing parallel use.
+
+Simple syntax errors will be caught by the pre-processing step. This happens without a lock to reduce the single lock bottleneck.
+
+# Sketch Cache
+
+Sketchs are aggresively finger-printed and stored in a cache. White space, comments, and other superficial data will be stripped out during pre-processing and minimization for fingerprinting. This source file decimation is only used for finger
+printing while the actual source files are sent to compiler to preserve line numbers and file names.
+
+This pre-processing done is done via gcc and special regex's and will happen without a lock. This will allow you to have extremely quick recompiles for whitespace and changes in comments even if the compiler is executing under it's lock.
+
+# Local compiles
+
+If the web-compiler get's congested then it's recommend that you run the compiler locally. This requires docker and will be invoked whenever you pass in `--local`. This will first pull the most recent Docker image of the Fastled compiler, launching a webserver and then connecting to it with the client once it's been up.
+
+# Auto updates
+
+In server mode the git repository will be cloned as a side repo and then periodically updated and rsync'd to the src directory. This allows a long running instance to stay updated.
+
+### Wasm compatibility with Arduino sketchs
+
+The compatibility is actually pretty good. Most simple sketchs should compile out of the box. Even some of the avr platform includes are stubbed out to make it work. The familiar `digitalWrite()`, `Serial.println()` and other common functions work. Although `digitalRead()` will always return 0 and `analogRead()` will return random numbers.
+
+### Faqs
+
+Q: How often is the docker image updated?
+A: It's scheduled for rebuild once a day at 3am Pacific time, and also on every change to this repo.
+
+Q: How can I run my own cloud instance of the FastLED wasm compiler?
+A: Render.com (which fastled is hosted on) or DigialOcean can accept a github repo and auto-build the docker image.
+
+Q: Why does FastLED tend to become choppy when the browser is in the background?
+A: FastLED Wasm currently runs on the main thread and therefor Chrome will begin throttling the event loop when the browser is not in the foreground. The solution to this is to move FastLED to a web worker where it will get a background thread that Chrome / Firefox won't throttle.
+
+Q: Why does a long `delay()` cause the browser to freeze and become sluggish?
+A: `delay()` will block `loop()` which blocks the main thread of the browser. The solution is a webworker which will not affect main thread performance of the browser.
+
+
+Q: How can I get the compiled size of my FastLED sketch smaller?
+A: A big chunk of space is being used by unnecessary javascript `emscripten` is  bundling. This can be tweeked by the wasm_compiler_settings.py file in the FastLED repo.
+
+
+# Revisions
+
+  * 1.1.15 - Fixed logic for considering ipv6 addresses. Auto selection of ipv6 is now restored.
+  * 1.1.14 - Fixes for regression in using --server and --localhost as two instances, this is now under test.
+  * 1.1.13 - Disable the use of ipv6. It produces random timeouts on the onrender server we are using for the web compiler.
+  * 1.1.12 - By default, fastled will default to the web compiler. `--localhost` to either attach to an existing server launched with `--server` or else one will be created automatically and launched.
+  * 1.1.11 - Dev improvement: FastLED src code volume mapped into docker will just in time update without having to manually trigger it.
+  * 1.1.10 - Swap large assets with embedded placeholders. This helps video sketches upload and compile instantly. Assets are re-added on after compile artifacts are returned.
+  * 1.1.9 - Remove auto server and instead tell the user corrective action to take.
+  * 1.1.8 - Program now knows it's own version which will be displayed with help file. Use `--version` to get it directly.
+  * 1.1.7 - Sketch cache re-enabled, but selectively invalidated on cpp/h updates. Cleaned up deprecated args. Fixed double thread running for containers that was causing slowdown.
+  * 1.1.6 - Use the fast src volume map allow quick updates to fastled when developing on the source code.
+  * 1.1.5 - Filter out hidden files and directories from being included in the sketch archive sent to the compiler.
+  * 1.1.4 - Fix regression introduced by testing out ipv4/ipv6 connections from a thread pool.
+  * 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`
+  * 1.0.15 - `fled` is an alias of `fastled-wasm` and will eventually replace it. `--web-host` was folded into `--web`, which if unspecified will attempt to run a local docker server and fallback to the cloud server if that fails. Specifying `--web` with no arguments will default to the cloud server while an argument (like `localhost`) will cause it to bind to that already running server for compilation.
+  * 1.0.14 - For non significant changes (comments, whitespace) in C++/ino/*.h files, compilation is skipped. This significantly reduces load on the server and prevents unnecessary local client browser refreshes.
+  * 1.0.13 - Increase speed of local compiles by running the server version of the compiler so it can keep it's cache and not have to pay docker startup costs because now it's a persistant server until exit.
+  * 1.0.12 - Added suppport for compile modes. Pass in `--release`, `--quick`, `--debug` for different compile options. We also support `--profile` to profile the build process.
+  * 1.0.11 - `--web` compile will automatically be enabled if the local build using docker fails.
+  * 1.0.10 - Watching files is now available for `--web`
+  * 1.0.9 - Enabled web compile. Access it with `--web` or `--web-host`
+  * 1.0.8 - Allow more than one fastled-wasm browser instances to co-exist by searching for unused ports after 8081.
+  * 1.0.7 - Docker multi image build implemented, tool now points to new docker image compile.
+  * 1.0.6 - Removed `--no-open` and `--watch`, `--watch` is now assumed unless `--just-compile` is used.
+  * 1.0.5 - Implemented `--update` to update the compiler image from the docker registry.
+  * 1.0.4 - Implemented `--watch` which will watch for changes and then re-launch the compilation step.
+  * 1.0.3 - Integrated `live-server` to launch when available.
+  * 1.0.2 - Small bug with new installs.
+  * 1.0.1 - Re-use is no longer the default, due to problems.
+  * 1.0.0 - Initial release.

{fastled-1.0.11.dist-info → fastled-1.0.15.dist-info}/RECORD

@@ -1,20 +1,20 @@
-fastled/__init__.py,sha256=f3KhION06nm0tJFF8POOIXhKebdmWIMlx8mVEmVFUrw,64
-fastled/app.py,sha256=WpcXlNUJzMPmH6BZIK6S15SGiAWtQmXungxlw0uOooc,13955
+fastled/__init__.py,sha256=zQpKt-iwGAnHw59eTxrM5GT1LFsHFobeuFTRsfgMaAI,64
+fastled/app.py,sha256=fKIpWYKed8ENfPrWD0jFXZJfh6E4D9_W2xB3w0xgr7o,15054
 fastled/build_mode.py,sha256=joMwsV4K1y_LijT4gEAcjx69RZBoe_KmFmHZdPYbL_4,631
 fastled/cli.py,sha256=CNR_pQR0sNVPNuv8e_nmm-0PI8sU-eUBUgnWgWkzW9c,237
-fastled/compile_server.py,sha256=-Qd9x0l-KfiFRGqZYOi3BRD7iEqfJmJU6EgFY-QJodg,7919
+fastled/compile_server.py,sha256=baXSd8V3C2tA--oYl8-_TPEvJxtNYck788W-iT-xyi8,8022
 fastled/docker_manager.py,sha256=gaDZpFV7E-9JhYIn6ahkP--9dGT32-WR5wZaU-o--6g,9107
 fastled/filewatcher.py,sha256=fJNMQRDCpihSL4nQeYPqbD4m1Jzjcz_-YRAo-wlPW6k,6518
-fastled/keyboard.py,sha256=PiAUhga8R_crMqFQRwjKyg6bgVTMlpezWa0gaGmL_So,2542
+fastled/keyboard.py,sha256=vlyJDae9yOHkGQ0R1RgYwNCIafg5lslGZ_41Jz_EC1g,2667
 fastled/open_browser.py,sha256=RRHcsZ5Vzsw1AuZUEYuSfjKmf_9j3NGMDUR-FndHmqs,1483
 fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
 fastled/sketch.py,sha256=KhhPFqlFVlBk8YrzFy7-ioe7zEzecgrVLhyFbLpBp7k,1845
 fastled/util.py,sha256=t4M3NFMhnCzfYbLvIyJi0RdFssZqbTN_vVIaej1WV-U,265
-fastled/web_compile.py,sha256=jN9p-ODWm_EspFlsT4M7SfyI_wAdi17u7_JEIef5WVw,9645
+fastled/web_compile.py,sha256=PfNTYazlFCJhJxYGsBsv4HaLVIvmF-rPSc1NE9gIaPo,10674
 fastled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
-fastled-1.0.11.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-fastled-1.0.11.dist-info/METADATA,sha256=vi_VLpN90hbv8hxpGib2nRtRTYj5GBnoakQccKh7iuY,6780
-fastled-1.0.11.dist-info/WHEEL,sha256=0VNUDWQJzfRahYI3neAhz2UVbRCtztpN5dPHAGvmGXc,109
-fastled-1.0.11.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
-fastled-1.0.11.dist-info/top_level.txt,sha256=xfG6Z_ol9V5YmBROkZq2QTRwjbS2ouCUxaTJsOwfkOo,14
-fastled-1.0.11.dist-info/RECORD,,
+fastled-1.0.15.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.0.15.dist-info/METADATA,sha256=30X9yHNZlNBJ_MpRQ5722V7Yu2aqgNEwcQvXcZkjXgI,13230
+fastled-1.0.15.dist-info/WHEEL,sha256=0VNUDWQJzfRahYI3neAhz2UVbRCtztpN5dPHAGvmGXc,109
+fastled-1.0.15.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.0.15.dist-info/top_level.txt,sha256=xfG6Z_ol9V5YmBROkZq2QTRwjbS2ouCUxaTJsOwfkOo,14
+fastled-1.0.15.dist-info/RECORD,,

fastled-1.0.11.dist-info/METADATA

@@ -1,126 +0,0 @@
-Metadata-Version: 2.1
-Name: fastled
-Version: 1.0.11
-Summary: FastLED Wasm Compiler
-Home-page: https://github.com/zackees/fastled-wasm
-Maintainer: Zachary Vorhies
-License: BSD 3-Clause License
-Keywords: template-python-cmd
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: docker
-Requires-Dist: httpx
-Requires-Dist: watchdog
-Requires-Dist: livereload
-Requires-Dist: download
-Requires-Dist: filelock
-Requires-Dist: windows-curses; platform_system == "Windows"
-
-# FastLED wasm compiler
-
-Compiles an Arduino/Platformio sketch into a wasm binary that can be run directly in the web browser.
-
-
-[![Linting](https://github.com/zackees/fastled-wasm/actions/workflows/lint.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/lint.yml)
-[![Build and Push Multi Docker Image](https://github.com/zackees/fastled-wasm/actions/workflows/build_multi_docker_image.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/build_multi_docker_image.yml)
-[![MacOS_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_macos.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_macos.yml)
-[![Ubuntu_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_ubuntu.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_ubuntu.yml)
-[![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.
-
-Compile times are extremely fast - I've seen as low as 5 seconds but 8-15 seconds is typical.
-
-This works on Windows/Linux/Mac(arm/x64).
-
-Docker is required.
-
-https://github.com/user-attachments/assets/64ae0e6c-5f8b-4830-ab87-dcc25bc61218
-
-# Demo
-
-https://zackees.github.io/fastled-wasm/
-
-
-
-# Install
-
-```bash
-pip install fastled-wasm
-```
-
-**Note that you may need to install x86 docker emulation on Mac-m1 and later, as this is an x86 only image at the prsent.**
-
-# Use
-
-Change to the directory where the sketch lives and run
-
-```bash
-cd <SKETCH-DIRECTORY>
-fastled-wasm
-```
-
-Or if you don't have docker then use our web compiler
-
-```bash
-cd <SKETCH-DIRECTORY>
-fastled-wasm --web
-```
-
-After compilation a web browser windows will pop up.
-
-# Hot reload by default
-
-Once launched, the compiler will remain open, listening to changes and recompiling as necessary and hot-reloading the sketch into the current browser.
-
-This style of development should be familiar to those doing web development.
-
-# Data
-
-If you want to embed data, then do so in the `data/` directory at the project root. The files will appear in the `data/` director of any spawned FileSystem or SDCard.
-
-
-### About the compilation.
-
-Pre-processing is done to your source files. A fake Arduino.h will be inserted into your source files that will
-provide shims for most of the common api points.
-
-
-
-# Revisions
-
-  * 1.1.11 - Dev improvement: FastLED src code volume mapped into docker will just in time update without having to manually trigger it.
-  * 1.1.10 - Swap large assets with embedded placeholders. This helps video sketches upload and compile instantly. Assets are re-added on after compile artifacts are returned.
-  * 1.1.9 - Remove auto server and instead tell the user corrective action to take.
-  * 1.1.8 - Program now knows it's own version which will be displayed with help file. Use `--version` to get it directly.
-  * 1.1.7 - Sketch cache re-enabled, but selectively invalidated on cpp/h updates. Cleaned up deprecated args. Fixed double thread running for containers that was causing slowdown.
-  * 1.1.6 - Use the fast src volume map allow quick updates to fastled when developing on the source code.
-  * 1.1.5 - Filter out hidden files and directories from being included in the sketch archive sent to the compiler.
-  * 1.1.4 - Fix regression introduced by testing out ipv4/ipv6 connections from a thread pool.
-  * 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`
-  * 1.0.15 - `fled` is an alias of `fastled-wasm` and will eventually replace it. `--web-host` was folded into `--web`, which if unspecified will attempt to run a local docker server and fallback to the cloud server if that fails. Specifying `--web` with no arguments will default to the cloud server while an argument (like `localhost`) will cause it to bind to that already running server for compilation.
-  * 1.0.14 - For non significant changes (comments, whitespace) in C++/ino/*.h files, compilation is skipped. This significantly reduces load on the server and prevents unnecessary local client browser refreshes.
-  * 1.0.13 - Increase speed of local compiles by running the server version of the compiler so it can keep it's cache and not have to pay docker startup costs because now it's a persistant server until exit.
-  * 1.0.12 - Added suppport for compile modes. Pass in `--release`, `--quick`, `--debug` for different compile options. We also support `--profile` to profile the build process.
-  * 1.0.11 - `--web` compile will automatically be enabled if the local build using docker fails.
-  * 1.0.10 - Watching files is now available for `--web`
-  * 1.0.9 - Enabled web compile. Access it with `--web` or `--web-host`
-  * 1.0.8 - Allow more than one fastled-wasm browser instances to co-exist by searching for unused ports after 8081.
-  * 1.0.7 - Docker multi image build implemented, tool now points to new docker image compile.
-  * 1.0.6 - Removed `--no-open` and `--watch`, `--watch` is now assumed unless `--just-compile` is used.
-  * 1.0.5 - Implemented `--update` to update the compiler image from the docker registry.
-  * 1.0.4 - Implemented `--watch` which will watch for changes and then re-launch the compilation step.
-  * 1.0.3 - Integrated `live-server` to launch when available.
-  * 1.0.2 - Small bug with new installs.
-  * 1.0.1 - Re-use is no longer the default, due to problems.
-  * 1.0.0 - Initial release.