fastled 1.0.8__py2.py3-none-any.whl

fastled/compile_server.py

@@ -0,0 +1,251 @@
+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

fastled/docker_manager.py

@@ -0,0 +1,259 @@
+"""Docker management functionality for FastLED WASM compiler."""
+
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import docker  # type: ignore
+from filelock import FileLock
+
+TAG = "main"
+
+_HERE = Path(__file__).parent
+_FILE_LOCK = FileLock(str(_HERE / "fled.lock"))
+
+
+def _win32_docker_location() -> str | None:
+    home_dir = Path.home()
+    out = [
+        "C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe",
+        f"{home_dir}\\AppData\\Local\\Docker\\Docker Desktop.exe",
+    ]
+    for loc in out:
+        if Path(loc).exists():
+            return loc
+    return None
+
+
+class DockerManager:
+    """Manages Docker operations for FastLED WASM compiler."""
+
+    def __init__(self, container_name: str):
+        self.container_name = container_name
+
+    @staticmethod
+    def is_docker_installed() -> bool:
+        """Check if Docker is installed on the system."""
+        try:
+            subprocess.run(["docker", "--version"], capture_output=True, check=True)
+            print("Docker is installed.")
+            return True
+        except subprocess.CalledProcessError as e:
+            print(f"Docker command failed: {str(e)}")
+            return False
+        except FileNotFoundError:
+            print("Docker is not installed.")
+            return False
+
+    def is_running(self) -> bool:
+        """Check if Docker is running by pinging the Docker daemon."""
+        try:
+            client = docker.from_env()
+            client.ping()
+            print("Docker is running.")
+            return True
+        except docker.errors.DockerException as e:
+            print(f"Docker is not running: {str(e)}")
+            return False
+
+    def start(self) -> bool:
+        """Attempt to start Docker Desktop (or the Docker daemon) automatically."""
+        print("Attempting to start Docker...")
+
+        try:
+            if sys.platform == "win32":
+                docker_path = _win32_docker_location()
+                if not docker_path:
+                    print("Docker Desktop not found.")
+                    return False
+                subprocess.run(["start", "", docker_path], shell=True)
+            elif sys.platform == "darwin":
+                subprocess.run(["open", "/Applications/Docker.app"])
+            elif sys.platform.startswith("linux"):
+                subprocess.run(["sudo", "systemctl", "start", "docker"])
+            else:
+                print("Unknown platform. Cannot auto-launch Docker.")
+                return False
+
+            # Wait for Docker to start up with increasing delays
+            print("Waiting for Docker Desktop to start...")
+            attempts = 0
+            max_attempts = 20  # Increased max wait time
+            while attempts < max_attempts:
+                attempts += 1
+                if self.is_running():
+                    print("Docker started successfully.")
+                    return True
+
+                # Gradually increase wait time between checks
+                wait_time = min(5, 1 + attempts * 0.5)
+                print(
+                    f"Docker not ready yet, waiting {wait_time:.1f}s... (attempt {attempts}/{max_attempts})"
+                )
+                time.sleep(wait_time)
+
+            print("Failed to start Docker within the expected time.")
+            print(
+                "Please try starting Docker Desktop manually and run this command again."
+            )
+        except KeyboardInterrupt:
+            print("Aborted by user.")
+            raise
+        except Exception as e:
+            print(f"Error starting Docker: {str(e)}")
+        return False
+
+    def ensure_linux_containers(self) -> bool:
+        """Ensure Docker is using Linux containers on Windows."""
+        if sys.platform == "win32":
+            try:
+                # Check if we're already in Linux container mode
+                result = subprocess.run(
+                    ["docker", "info"], capture_output=True, text=True, check=True
+                )
+                if "linux" in result.stdout.lower():
+                    return True
+
+                print("Switching to Linux containers...")
+                subprocess.run(
+                    ["cmd", "/c", "docker context ls"], check=True, capture_output=True
+                )
+                subprocess.run(
+                    ["cmd", "/c", "docker context use default"],
+                    check=True,
+                    capture_output=True,
+                )
+                return True
+            except subprocess.CalledProcessError as e:
+                print(f"Failed to switch to Linux containers: {e}")
+                print(f"stdout: {e.stdout}")
+                print(f"stderr: {e.stderr}")
+                return False
+        return True  # Non-Windows platforms don't need this
+
+    def get_lock(self) -> FileLock:
+        """Get the file lock for this DockerManager instance."""
+        return _FILE_LOCK
+
+    def ensure_image_exists(self, force_update: bool = False) -> bool:
+        """Check if local image exists, pull from remote if not or if update requested."""
+
+        try:
+            if not self.ensure_linux_containers():
+                return False
+
+            image_name = f"{self.container_name}:{TAG}"
+            remote_image = f"niteris/fastled-wasm:{TAG}"
+            print("Pulling latest")
+            cmd_check_newer_image = [
+                "docker",
+                "pull",
+                remote_image,
+            ]
+            result = subprocess.run(
+                cmd_check_newer_image,
+                text=True,
+                check=False,
+            )
+            if result.returncode != 0:
+                print("Failed to check for newer image.")
+                return False
+            print("Tagging image")
+
+            tag_result = subprocess.run(
+                [
+                    "docker",
+                    "tag",
+                    remote_image,
+                    image_name,
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if tag_result.returncode != 0:
+                print(f"Failed to tag image: {tag_result.stderr}")
+                return False
+            return True
+        except subprocess.CalledProcessError as e:
+            print(f"Failed to ensure image exists: {e}")
+            return False
+
+    def container_exists(self) -> bool:
+        """Check if a container with the given name exists."""
+        try:
+            result = subprocess.run(
+                ["docker", "container", "inspect", self.container_name],
+                capture_output=True,
+                check=False,
+            )
+            return result.returncode == 0
+        except subprocess.CalledProcessError:
+            return False
+
+    def remove_container(self) -> bool:
+        """Remove a container if it exists."""
+        try:
+            subprocess.run(
+                ["docker", "rm", "-f", self.container_name],
+                check=True,
+            )
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def full_container_name(self) -> str:
+        """Get the name of the container."""
+        return f"{self.container_name}:{TAG}"
+
+    def run_container(
+        self,
+        cmd: list[str],
+        volumes: dict[str, dict[str, str]] | None = None,
+        ports: dict[int, int] | None = None,
+    ) -> subprocess.Popen:
+        """Run the Docker container with the specified volume.
+
+        Args:
+            cmd: Command to run in the container
+            volumes: Dict mapping host paths to dicts with 'bind' and 'mode' keys
+            ports: Dict mapping host ports to container ports
+        """
+        volumes = volumes or {}
+        ports = ports or {}
+
+        print("Creating new container...")
+        docker_command = ["docker", "run"]
+
+        if sys.stdout.isatty():
+            docker_command.append("-it")
+        # Attach volumes if specified
+        docker_command += [
+            "--name",
+            self.container_name,
+        ]
+        if ports:
+            for host_port, container_port in ports.items():
+                docker_command.extend(["-p", f"{host_port}:{container_port}"])
+        if volumes:
+            for host_path, mount_spec in volumes.items():
+                docker_command.extend(
+                    ["-v", f"{host_path}:{mount_spec['bind']}:{mount_spec['mode']}"]
+                )
+
+        docker_command.extend(
+            [
+                f"{self.container_name}:{TAG}",
+            ]
+        )
+        docker_command.extend(cmd)
+
+        print(f"Running command: {' '.join(docker_command)}")
+
+        process = subprocess.Popen(
+            docker_command,
+            text=True,
+        )
+
+        return process

fastled/filewatcher.py

@@ -0,0 +1,146 @@
+"""File system watcher implementation using watchdog
+"""
+
+import hashlib
+import queue
+import threading
+import time
+from pathlib import Path
+from typing import Dict, Set
+
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
+from watchdog.observers import Observer
+from watchdog.observers.api import BaseObserver
+
+
+class MyEventHandler(FileSystemEventHandler):
+    def __init__(
+        self,
+        change_queue: queue.Queue,
+        excluded_patterns: Set[str],
+        file_hashes: Dict[str, str],
+    ) -> None:
+        super().__init__()
+        self.change_queue = change_queue
+        self.excluded_patterns = excluded_patterns
+        self.file_hashes = file_hashes
+
+    def _get_file_hash(self, filepath: str) -> str:
+        try:
+            with open(filepath, "rb") as f:
+                return hashlib.md5(f.read()).hexdigest()
+        except Exception:  # pylint: disable=broad-except
+            return ""
+
+    def on_modified(self, event: FileSystemEvent) -> None:
+        if not event.is_directory:
+            path = Path(event.src_path)
+            # Check if any part of the path matches excluded patterns
+            if not any(part in self.excluded_patterns for part in path.parts):
+                new_hash = self._get_file_hash(event.src_path)
+                if new_hash and new_hash != self.file_hashes.get(event.src_path):
+                    self.file_hashes[event.src_path] = new_hash
+                    self.change_queue.put(event.src_path)
+
+
+class FileChangedNotifier(threading.Thread):
+    """Watches a directory for file changes and queues notifications"""
+
+    def __init__(
+        self,
+        path: str,
+        debounce_seconds: float = 1.0,
+        excluded_patterns: list[str] | None = None,
+    ) -> None:
+        """Initialize the notifier with a path to watch
+
+        Args:
+            path: Directory path to watch for changes
+            debounce_seconds: Minimum time between notifications for the same file
+            excluded_patterns: List of directory/file patterns to exclude from watching
+        """
+        super().__init__(daemon=True)
+        self.path = path
+        self.observer: BaseObserver | None = None
+        self.event_handler: MyEventHandler | None = None
+
+        # Combine default and user-provided patterns
+        self.excluded_patterns = (
+            set(excluded_patterns) if excluded_patterns is not None else set()
+        )
+        self.stopped = False
+        self.change_queue: queue.Queue = queue.Queue()
+        self.last_notification: Dict[str, float] = {}
+        self.file_hashes: Dict[str, str] = {}
+        self.debounce_seconds = debounce_seconds
+
+    def stop(self) -> None:
+        """Stop watching for changes"""
+        print("watcher stop")
+        self.stopped = True
+        if self.observer:
+            self.observer.stop()
+            self.observer.join()
+            self.observer = None
+            self.event_handler = None
+
+    def run(self) -> None:
+        """Thread main loop - starts watching for changes"""
+        self.event_handler = MyEventHandler(
+            self.change_queue, self.excluded_patterns, self.file_hashes
+        )
+        self.observer = Observer()
+        self.observer.schedule(self.event_handler, self.path, recursive=True)
+        self.observer.start()
+
+        try:
+            while not self.stopped:
+                time.sleep(0.1)
+        except KeyboardInterrupt:
+            print("File watcher stopped by user.")
+        finally:
+            self.stop()
+
+    def get_next_change(self, timeout: float = 0.001) -> str | None:
+        """Get the next file change event from the queue
+
+        Args:
+            timeout: How long to wait for next change in seconds
+
+        Returns:
+            Changed filepath or None if no change within timeout
+        """
+        try:
+            filepath = self.change_queue.get(timeout=timeout)
+            current_time = time.time()
+
+            # Check if we've seen this file recently
+            last_time = self.last_notification.get(filepath, 0)
+            if current_time - last_time < self.debounce_seconds:
+                return None
+
+            self.last_notification[filepath] = current_time
+            return filepath
+        except KeyboardInterrupt:
+            raise
+        except queue.Empty:
+            return None
+
+    def get_all_changes(self, timeout: float = 0.001) -> list[str]:
+        """Get all file change events from the queue
+
+        Args:
+            timeout: How long to wait for next change in seconds
+
+        Returns:
+            List of changed filepaths
+        """
+        changed_files = []
+        while True:
+            changed_file = self.get_next_change(timeout=timeout)
+            if changed_file is None:
+                break
+            changed_files.append(changed_file)
+        # clear all the changes from the queue
+        self.change_queue.queue.clear()
+        return changed_files

fastled/open_browser.py

@@ -0,0 +1,48 @@
+import socket
+import subprocess
+from pathlib import Path
+
+DEFAULT_PORT = 8081
+
+
+def _open_browser_python(fastled_js: Path, port: int) -> subprocess.Popen:
+    """Start livereload server in the fastled_js directory using CLI"""
+    print(f"\nStarting livereload server in {fastled_js} on port {port}")
+
+    # Construct command for livereload CLI
+    cmd = [
+        "livereload",
+        str(fastled_js),  # directory to serve
+        "--port",
+        str(port),
+        "-t",
+        str(fastled_js / "index.html"),  # file to watch
+        "-w",
+        "0.1",  # delay
+        "-o",
+        "0.5",  # open browser delay
+    ]
+
+    # Start the process
+    process = subprocess.Popen(cmd)
+    return process
+
+
+def _find_open_port(start_port: int) -> int:
+    """Find an open port starting from start_port."""
+    port = start_port
+    while True:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            if sock.connect_ex(("localhost", port)) != 0:
+                return port
+            port += 1
+
+
+def open_browser_thread(fastled_js: Path, port: int | None = None) -> subprocess.Popen:
+    """Start livereload server in the fastled_js directory and return the started thread"""
+    if port is None:
+        port = DEFAULT_PORT
+
+    port = _find_open_port(port)
+
+    return _open_browser_python(fastled_js, port)