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

fastled/compile_server.py

@@ -1,251 +1,222 @@
-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()
+        # 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
+
+    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