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

fastled/__init__.py

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

fastled/app.py

@@ -17,7 +17,8 @@ from fastled import __version__
 from fastled.build_mode import BuildMode, get_build_mode
 from fastled.compile_server import CompileServer
 from fastled.docker_manager import DockerManager
-from fastled.filewatcher import create_file_watcher_process
+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
@@ -291,41 +292,66 @@ def run_client(args: argparse.Namespace) -> int:
             compile_server.stop()
         return 1
 
-    # Watch mode
     print("\nWatching for changes. Press Ctrl+C to stop...")
-    # watcher = FileChangedNotifier(args.directory, excluded_patterns=["fastled_js"])
-    # watcher.start()
-
-    from multiprocessing import Process, Queue
-
-    proc: Process
-    queue: Queue
-    proc, queue = create_file_watcher_process(
+    sketch_filewatcher = FileWatcherProcess(
         args.directory, excluded_patterns=["fastled_js"]
     )
 
+    source_code_watcher: FileWatcherProcess | None = None
+    if compile_server and compile_server.using_fastled_src_dir_volume():
+        assert compile_server.fastled_src_dir is not None
+        source_code_watcher = FileWatcherProcess(
+            compile_server.fastled_src_dir, excluded_patterns=[]
+        )
+
+    def trigger_rebuild_if_sketch_changed(
+        last_compiled_result: CompiledResult,
+    ) -> CompiledResult:
+        changed_files = sketch_filewatcher.get_all_changes()
+        if changed_files:
+            print(f"\nChanges detected in {changed_files}")
+            last_hash_value = last_compiled_result.hash_value
+            out = compile_function(last_hash_value=last_hash_value)
+            if not out.success:
+                print("\nRecompilation failed.")
+            else:
+                print("\nRecompilation successful.")
+            return out
+        return last_compiled_result
+
     try:
         while True:
-            try:
-                size = queue.qsize()
-                changed_files = []
-                for i in range(size):
-                    changed_files.append(queue.get())
-            except KeyboardInterrupt:
-                print("\nExiting from watcher...")
-                raise
-            except Exception as e:
-                print(f"Error getting changes: {e}")
-                changed_files = []
-            if changed_files:
-                print(f"\nChanges detected in {changed_files}")
-                last_hash_value = last_compiled_result.hash_value
-                result = compile_function(last_hash_value=last_hash_value)
-                if not result.success:
-                    print("\nRecompilation failed.")
-                else:
-                    print("\nRecompilation successful.")
-            time.sleep(0.3)
+            last_compiled_result = trigger_rebuild_if_sketch_changed(
+                last_compiled_result
+            )
+            if compile_server and not compile_server.proceess_running():
+                print("Server process is not running. Exiting...")
+                return 1
+            if source_code_watcher is not None:
+                changed_files = source_code_watcher.get_all_changes()
+                if changed_files:
+                    print(f"\nChanges detected in FastLED source code: {changed_files}")
+                    print("Press space bar to trigger compile.")
+
+                    space_key_watcher = SpaceBarWatcher()
+                    try:
+                        while True:
+                            if space_key_watcher.space_bar_pressed():
+                                print("Space bar pressed, triggering recompile...")
+                                last_compiled_result = compile_function(
+                                    last_hash_value=None
+                                )
+                                print("Finished recompile.")
+                                break
+                            elif len(sketch_filewatcher.get_all_changes()) > 0:
+                                last_compiled_result = compile_function(
+                                    last_hash_value=None
+                                )
+                                break
+                            time.sleep(0.1)
+                    finally:
+                        space_key_watcher.stop()
+
     except KeyboardInterrupt:
         print("\nStopping watch mode...")
         return 0
@@ -333,7 +359,7 @@ def run_client(args: argparse.Namespace) -> int:
         print(f"Error: {e}")
         return 1
     finally:
-        proc.terminate()
+        sketch_filewatcher.stop()
         if compile_server:
             compile_server.stop()
         if browser_proc:
@@ -372,8 +398,8 @@ def main() -> int:
 
 if __name__ == "__main__":
     try:
+        os.chdir("../fastled")
         sys.argv.append("examples/SdCard")
-        sys.argv.append("--local")
         sys.exit(main())
     except KeyboardInterrupt:
         print("\nExiting from main...")

fastled/compile_server.py

@@ -1,251 +1,216 @@
-import socket
-import subprocess
-import threading
-import time
-from pathlib import Path
-from typing import Optional
-
-import httpx
-
-from fastled.docker_manager import DockerManager
-from fastled.sketch import looks_like_fastled_repo
-
-_DEFAULT_CONTAINER_NAME = "fastled-wasm-compiler"
-
-SERVER_PORT = 9021
-
-
-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
-    while True:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            if s.connect_ex(("localhost", port)) != 0:
-                return port
-            port += 1
-            if port >= end_port:
-                raise RuntimeError("No available ports found")
-
-
-class CompileServer:
-    def __init__(
-        self,
-        container_name=_DEFAULT_CONTAINER_NAME,
-        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.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:
-        return self._port
-
-    def url(self) -> str:
-        return f"http://localhost:{self._port}"
-
-    def wait_for_startup(self, timeout: int = 100) -> bool:
-        """Wait for the server to start up."""
-        start_time = time.time()
-        while time.time() - start_time < timeout:
-            # ping the server to see if it's up
-            if not self._port:
-                return False
-            # use httpx to ping the server
-            # if successful, return True
-            try:
-                response = httpx.get(
-                    f"http://localhost:{self._port}", follow_redirects=True
-                )
-                if response.status_code < 400:
-                    return True
-            except KeyboardInterrupt:
-                raise
-            except Exception:
-                pass
-            time.sleep(0.1)
-            if not self.running:
-                return False
-        return False
-
-    def _start(self) -> int:
-        print("Compiling server starting")
-        self.running = True
-        # Ensure Docker is running
-        with self.docker.get_lock():
-            if not self.docker.is_running():
-                if not self.docker.start():
-                    print("Docker could not be started. Exiting.")
-                    raise RuntimeError("Docker could not be started. Exiting.")
-
-            # Clean up any existing container with the same name
-
-            try:
-                container_exists = (
-                    subprocess.run(
-                        ["docker", "inspect", self.container_name],
-                        capture_output=True,
-                        text=True,
-                    ).returncode
-                    == 0
-                )
-                if container_exists:
-                    print("Cleaning up existing container")
-                    subprocess.run(
-                        ["docker", "rm", "-f", self.container_name],
-                        check=False,
-                    )
-            except KeyboardInterrupt:
-                raise
-            except Exception as e:
-                print(f"Warning: Failed to remove existing container: {e}")
-
-            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")
-
-        print("Docker image now validated")
-
-        # Remove the image to force a fresh download
-        # subprocess.run(["docker", "rmi", "fastled-wasm"], capture_output=True)
-        # print("All clean")
-
-        port = find_available_port()
-        print(f"Found an available port: {port}")
-        # server_command = ["python", "/js/run.py", "server", "--allow-shutdown"]
-        if self.interactive:
-            server_command = ["/bin/bash"]
-        else:
-            server_command = ["python", "/js/run.py", "server"]
-        print(f"Started Docker container with command: {server_command}")
-        ports = {port: 80}
-        volumes = None
-        if self.fastled_src_dir:
-            print(
-                f"Mounting FastLED source directory {self.fastled_src_dir} into container /host/fastled/src"
-            )
-            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
-        )
-        print("Compile server starting")
-        time.sleep(3)
-        if self.running_process.poll() is not None:
-            print("Server failed to start")
-            self.running = False
-            raise RuntimeError("Server failed to start")
-        self.thread = threading.Thread(target=self._server_loop, daemon=True)
-        self.thread.start()
-
-        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
-        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 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)
-                if self.running_process.returncode is None:
-                    # kill
-                    self.running_process.kill()
-                if self.running_process.returncode is not None:
-                    print(
-                        f"Server stopped with return code {self.running_process.returncode}"
-                    )
-
-        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:
-            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
-        # Signal the server thread to stop
-        self.running = False
-        if self.thread:
-            self.thread.join(timeout=10)  # Wait up to 10 seconds for thread to finish
-            if self.thread.is_alive():
-                print("Warning: Server thread did not terminate properly")
-
-        print("Compile server stopped")
-
-    def _server_loop(self) -> None:
-        try:
-            while self.running:
-                if self.running_process:
-                    # Read Docker container output
-                    # Check if Docker process is still running
-                    if self.running_process.poll() is not None:
-                        print("Docker server stopped unexpectedly")
-                        self.running = False
-                        break
-
-                time.sleep(0.1)  # Prevent busy waiting
-        except KeyboardInterrupt:
-            print("Server thread stopped by user.")
-        except Exception as e:
-            print(f"Error in server thread: {e}")
-        finally:
-            self.running = False
+import socket
+import subprocess
+import time
+from pathlib import Path
+
+import httpx
+
+from fastled.docker_manager import DockerManager
+from fastled.sketch import looks_like_fastled_repo
+
+_DEFAULT_CONTAINER_NAME = "fastled-wasm-compiler"
+
+SERVER_PORT = 9021
+
+
+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
+    while True:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            if s.connect_ex(("localhost", port)) != 0:
+                return port
+            port += 1
+            if port >= end_port:
+                raise RuntimeError("No available ports found")
+
+
+class CompileServer:
+    def __init__(
+        self,
+        container_name=_DEFAULT_CONTAINER_NAME,
+        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.docker = DockerManager(container_name=container_name)
+        self.running = False
+        self.running_process: subprocess.Popen | None = None
+        self.fastled_src_dir: Path | None = fastled_src_dir
+        self.interactive = interactive
+        self._port = self._start()
+
+    def using_fastled_src_dir_volume(self) -> bool:
+        return self.fastled_src_dir is not None
+
+    def port(self) -> int:
+        return self._port
+
+    def url(self) -> str:
+        return f"http://localhost:{self._port}"
+
+    def wait_for_startup(self, timeout: int = 100) -> bool:
+        """Wait for the server to start up."""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            # ping the server to see if it's up
+            if not self._port:
+                return False
+            # use httpx to ping the server
+            # if successful, return True
+            try:
+                response = httpx.get(
+                    f"http://localhost:{self._port}", follow_redirects=True
+                )
+                if response.status_code < 400:
+                    return True
+            except KeyboardInterrupt:
+                raise
+            except Exception:
+                pass
+            time.sleep(0.1)
+            if not self.running:
+                return False
+        return False
+
+    def _start(self) -> int:
+        print("Compiling server starting")
+        self.running = True
+        # Ensure Docker is running
+        with self.docker.get_lock():
+            if not self.docker.is_running():
+                if not self.docker.start():
+                    print("Docker could not be started. Exiting.")
+                    raise RuntimeError("Docker could not be started. Exiting.")
+
+            # Clean up any existing container with the same name
+            try:
+                container_exists = (
+                    subprocess.run(
+                        ["docker", "inspect", self.container_name],
+                        capture_output=True,
+                        text=True,
+                    ).returncode
+                    == 0
+                )
+                if container_exists:
+                    print("Cleaning up existing container")
+                    subprocess.run(
+                        ["docker", "rm", "-f", self.container_name],
+                        check=False,
+                    )
+            except KeyboardInterrupt:
+                raise
+            except Exception as e:
+                print(f"Warning: Failed to remove existing container: {e}")
+
+            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")
+
+        print("Docker image now validated")
+        port = find_available_port()
+        print(f"Found an available port: {port}")
+        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}")
+        ports = {port: 80}
+        volumes = None
+        if self.fastled_src_dir:
+            print(
+                f"Mounting FastLED source directory {self.fastled_src_dir} into container /host/fastled/src"
+            )
+            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
+        )
+        print("Compile server starting")
+        time.sleep(3)
+        if self.running_process.poll() is not None:
+            print("Server failed to start")
+            self.running = False
+            raise RuntimeError("Server failed to start")
+        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
+        # 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 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)
+                if self.running_process.returncode is None:
+                    # kill
+                    self.running_process.kill()
+                if self.running_process.returncode is not None:
+                    print(
+                        f"Server stopped with return code {self.running_process.returncode}"
+                    )
+
+        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:
+            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
+            self.running = False
+        print("Compile server stopped")

fastled/docker_manager.py

@@ -212,6 +212,7 @@ class DockerManager:
         cmd: list[str],
         volumes: dict[str, dict[str, str]] | None = None,
         ports: dict[int, int] | None = None,
+        tty: bool = False,
     ) -> subprocess.Popen:
         """Run the Docker container with the specified volume.
 
@@ -226,7 +227,8 @@ class DockerManager:
         print("Creating new container...")
         docker_command = ["docker", "run"]
 
-        if sys.stdout.isatty():
+        if tty:
+            assert sys.stdout.isatty(), "TTY mode requires a TTY"
             docker_command.append("-it")
         # Attach volumes if specified
         docker_command += [

fastled/filewatcher.py

@@ -2,11 +2,14 @@
 """
 
 import hashlib
+import os
 import queue
 import threading
 import time
+from contextlib import redirect_stdout
 from multiprocessing import Process, Queue
 from pathlib import Path
+from queue import Empty
 from typing import Dict, Set
 
 from watchdog.events import FileSystemEvent, FileSystemEventHandler
@@ -148,22 +151,46 @@ class FileChangedNotifier(threading.Thread):
 
 
 def _process_wrapper(root: Path, excluded_patterns: list[str], queue: Queue):
-    watcher = FileChangedNotifier(str(root), excluded_patterns=excluded_patterns)
-    watcher.start()
-    while True:
-        try:
-            changed_files = watcher.get_all_changes()
-            for file in changed_files:
-                queue.put(file)
-        except KeyboardInterrupt:
-            break
-    watcher.stop()
+    with open(os.devnull, "w") as fnull:  # Redirect to /dev/null
+        with redirect_stdout(fnull):
+            watcher = FileChangedNotifier(
+                str(root), excluded_patterns=excluded_patterns
+            )
+            watcher.start()
+            while True:
+                try:
+                    changed_files = watcher.get_all_changes()
+                    for file in changed_files:
+                        queue.put(file)
+                except KeyboardInterrupt:
+                    break
+            watcher.stop()
+
+
+class FileWatcherProcess:
+    def __init__(self, root: Path, excluded_patterns: list[str]) -> None:
+        self.queue: Queue = Queue()
+        self.process = Process(
+            target=_process_wrapper,
+            args=(root, excluded_patterns, self.queue),
+            daemon=True,
+        )
+        self.process.start()
+
+    def stop(self):
+        self.process.terminate()
+        self.process.join()
+        self.queue.close()
+        self.queue.join_thread()
 
+    def get_all_changes(self, timeout: float | None = None) -> list[str]:
+        changed_files = []
+        block = timeout is not None
 
-def create_file_watcher_process(
-    root: Path, excluded_patterns: list[str]
-) -> tuple[Process, Queue]:
-    """Create a new process running the file watcher"""
-    queue: Queue = Queue()
-    process = Process(target=_process_wrapper, args=(root, excluded_patterns, queue))
-    return process, queue
+        while True:
+            try:
+                changed_file = self.queue.get(block=block, timeout=timeout)
+                changed_files.append(changed_file)
+            except Empty:
+                break
+        return changed_files

fastled/keyboard.py

@@ -0,0 +1,89 @@
+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.")

fastled/open_browser.py

@@ -24,7 +24,11 @@ def _open_browser_python(fastled_js: Path, port: int) -> subprocess.Popen:
     ]
 
     # Start the process
-    process = subprocess.Popen(cmd)
+    process = subprocess.Popen(
+        cmd,
+        # stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
     return process
 
 

fastled/web_compile.py

@@ -4,7 +4,7 @@ import os
 import shutil
 import tempfile
 import zipfile
-from concurrent.futures import ThreadPoolExecutor, as_completed
+from concurrent.futures import ProcessPoolExecutor, as_completed
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -20,7 +20,7 @@ ENDPOINT_COMPILED_WASM = "compile/wasm"
 _TIMEOUT = 60 * 4  # 2 mins timeout
 _AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
 ENABLE_EMBEDDED_DATA = True
-_THREAD_POOL = ThreadPoolExecutor(max_workers=8)
+_EXECUTOR = ProcessPoolExecutor(max_workers=8)
 
 
 @dataclass
@@ -161,7 +161,7 @@ def web_compile(
         ip_versions = [True, False] if "localhost" not in host else [True]
         for ipv4 in ip_versions:
             for url in urls:
-                f = _THREAD_POOL.submit(_test_connection, url, ipv4)
+                f = _EXECUTOR.submit(_test_connection, url, ipv4)
                 futures.append(f)
 
         succeeded = False

{fastled-1.0.10.dist-info → fastled-1.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastled
-Version: 1.0.10
+Version: 1.0.11
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -16,6 +16,7 @@ Requires-Dist: watchdog
 Requires-Dist: livereload
 Requires-Dist: download
 Requires-Dist: filelock
+Requires-Dist: windows-curses; platform_system == "Windows"
 
 # FastLED wasm compiler
 
@@ -93,6 +94,7 @@ 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.

fastled-1.0.11.dist-info/RECORD

@@ -0,0 +1,20 @@
+fastled/__init__.py,sha256=f3KhION06nm0tJFF8POOIXhKebdmWIMlx8mVEmVFUrw,64
+fastled/app.py,sha256=WpcXlNUJzMPmH6BZIK6S15SGiAWtQmXungxlw0uOooc,13955
+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/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/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/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/check_cpp_syntax.py

@@ -1,34 +0,0 @@
-from pygments import lex
-from pygments.lexers import CppLexer
-from pygments.token import Token
-
-
-def check_cpp_syntax(code):
-    try:
-        # Tokenize the code to check for basic syntax issues
-        for token_type, token_value in lex(code, CppLexer()):
-            if token_type == Token.Error:
-                print(f"Syntax error detected: {token_value}")
-                return False
-        print("No syntax errors detected.")
-        return True
-    except Exception as e:
-        print(f"Error during syntax check: {e}")
-        return False
-
-
-def main():
-    file_path = input("Enter the path to your C++ file: ")
-    try:
-        with open(file_path, "r") as file:
-            code = file.read()
-        if check_cpp_syntax(code):
-            print("The file can now be sent to the server.")
-        else:
-            print("Please fix the syntax errors before sending.")
-    except FileNotFoundError:
-        print("File not found. Please check the path and try again.")
-
-
-if __name__ == "__main__":
-    main()

fastled-1.0.10.dist-info/RECORD

@@ -1,20 +0,0 @@
-fastled/__init__.py,sha256=8Zhmsg5KFQ2ogDbb2OFvaS5FPnsi76DJDmIxJh6z5Yg,64
-fastled/app.py,sha256=cRLPDB_GR1WkRNbmHPyyDiG4DAqpiB6MpFIyfa33_c4,12522
-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=8avG0mAjdjU0w1ej4LiKVGLgkHi8dZxT48TLuGecj7A,9451
-fastled/docker_manager.py,sha256=WcOKa3EpIPAjICPfTL87CUYuAmX9KYT6L_Hcqbj95eE,9028
-fastled/filewatcher.py,sha256=gwxNINttXQXJk3P4CpCav3-UwO3cbCg9k0ySGWOQYh0,5686
-fastled/open_browser.py,sha256=-VhpGmydwLCcXmrDD2esMEdJPZYcoX2Mt73eb88Nna0,1392
-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=Wl06e4nTAEXcn7N03eM0qLsMy4dPv6_hyZ4r7zyJJ1A,9649
-fastled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
-fastled-1.0.10.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-fastled-1.0.10.dist-info/METADATA,sha256=XmFMC3Pd1YlhemfA_aGSSetoNLvWnD4YFtOuPsxpRT4,6581
-fastled-1.0.10.dist-info/WHEEL,sha256=0VNUDWQJzfRahYI3neAhz2UVbRCtztpN5dPHAGvmGXc,109
-fastled-1.0.10.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
-fastled-1.0.10.dist-info/top_level.txt,sha256=xfG6Z_ol9V5YmBROkZq2QTRwjbS2ouCUxaTJsOwfkOo,14
-fastled-1.0.10.dist-info/RECORD,,