fastled 1.1.45__py3-none-any.whl

fastled/filewatcher.py

@@ -0,0 +1,202 @@
+"""File system watcher implementation using watchdog
+"""
+
+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
+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:
+            # Convert src_path to str if it's bytes
+            src_path = (
+                event.src_path.decode()
+                if isinstance(event.src_path, bytes)
+                else event.src_path
+            )
+            path = Path(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(src_path)
+                if new_hash and new_hash != self.file_hashes.get(src_path):
+                    self.file_hashes[src_path] = new_hash
+                    self.change_queue.put(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
+
+
+def _process_wrapper(root: Path, excluded_patterns: list[str], queue: Queue):
+    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
+
+        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,113 @@
+import os
+import select
+import sys
+import time
+from queue import Empty, Queue
+from threading import Thread
+
+_WHITE_SPACE = [" ", "\r", "\n"]
+
+
+# Original space bar, but now also enter key.
+class SpaceBarWatcher:
+
+    @classmethod
+    def watch_space_bar_pressed(cls, timeout: float = 0) -> bool:
+        watcher = cls()
+        try:
+            start_time = time.time()
+            while True:
+                if watcher.space_bar_pressed():
+                    return True
+                if time.time() - start_time > timeout:
+                    return False
+        finally:
+            watcher.stop()
+
+    def __init__(self) -> None:
+        self.queue: Queue = Queue()
+        self.queue_cancel: Queue = Queue()
+        self.process = Thread(target=self._watch_for_space, daemon=True)
+        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 in _WHITE_SPACE:
+                        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 in _WHITE_SPACE:
+                            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():
+            try:
+                key = self.queue.get(block=False, timeout=0.1)
+                if key == ord(" "):
+                    found = True
+                self.queue.task_done()
+            except Empty:
+                break
+        return found
+
+    def stop(self) -> None:
+        self.queue_cancel.put(True)
+        self.process.join()
+
+
+def main() -> None:
+    watcher = SpaceBarWatcher()
+    try:
+        while True:
+            if watcher.space_bar_pressed():
+                print("Space bar hit!")
+                break
+            time.sleep(1)
+    finally:
+        print("Stopping watcher.")
+        watcher.stop()
+        print("Watcher stopped.")
+    return
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("Keyboard interrupt detected.")

fastled/live_client.py

@@ -0,0 +1,69 @@
+import threading
+from pathlib import Path
+
+from fastled.compile_server import CompileServer
+from fastled.types import BuildMode
+
+
+class LiveClient:
+    """LiveClient class watches for changes and auto-triggeres rebuild."""
+
+    def __init__(
+        self,
+        sketch_directory: Path,
+        host: str | CompileServer | None = None,
+        auto_start: bool = True,
+        open_web_browser: bool = True,
+        keep_running: bool = True,
+        build_mode: BuildMode = BuildMode.QUICK,
+        profile: bool = False,
+    ) -> None:
+        self.sketch_directory = sketch_directory
+        self.host = host
+        self.open_web_browser = open_web_browser
+        self.keep_running = keep_running
+        self.build_mode = build_mode
+        self.profile = profile
+        self.auto_start = auto_start
+        self.shutdown = threading.Event()
+        self.thread: threading.Thread | None = None
+        if auto_start:
+            self.start()
+
+    def run(self) -> int:
+        """Run the client."""
+        from fastled.client_server import run_client  # avoid circular import
+
+        rtn = run_client(
+            directory=self.sketch_directory,
+            host=self.host,
+            open_web_browser=self.open_web_browser,
+            keep_running=self.keep_running,
+            build_mode=self.build_mode,
+            profile=self.profile,
+            shutdown=self.shutdown,
+        )
+        return rtn
+
+    @property
+    def running(self) -> bool:
+        return self.thread is not None and self.thread.is_alive()
+
+    def start(self) -> None:
+        """Start the client."""
+        assert not self.running, "LiveClient is already running"
+        self.shutdown.clear()
+        self.thread = threading.Thread(target=self.run, daemon=True)
+        self.thread.start()
+
+    def stop(self) -> None:
+        """Stop the client."""
+        self.shutdown.set()
+        if self.thread:
+            self.thread.join()
+            self.thread = None
+
+    def finalize(self) -> None:
+        """Finalize the client."""
+        self.stop()
+        self.thread = None

fastled/open_browser.py

@@ -0,0 +1,59 @@
+import os
+import socket
+import sys
+from multiprocessing import Process
+from pathlib import Path
+
+from livereload import Server
+
+DEFAULT_PORT = 8081
+
+
+def _open_browser_python(fastled_js: Path, port: int) -> Server:
+    """Start livereload server in the fastled_js directory using API"""
+    print(f"\nStarting livereload server in {fastled_js} on port {port}")
+
+    # server = Server()
+    # server.watch(str(fastled_js / "index.html"), delay=0.1)
+    # server.setHeader("Cache-Control", "no-cache")
+    # server.serve(root=str(fastled_js), port=port, open_url_delay=0.5)
+    # return server
+    os.system(f"cd {fastled_js} && live-server")
+
+
+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 _run_server(fastled_js: Path, port: int) -> None:
+    """Function to run in separate process that starts the livereload server"""
+    sys.stderr = open(os.devnull, "w")  # Suppress stderr output
+    _open_browser_python(fastled_js, port)
+    try:
+        # Keep the process running
+        while True:
+            pass
+    except KeyboardInterrupt:
+        print("\nShutting down livereload server...")
+
+
+def open_browser_process(fastled_js: Path, port: int | None = None) -> Process:
+    """Start livereload server in the fastled_js directory and return the process"""
+    if port is None:
+        port = DEFAULT_PORT
+
+    port = _find_open_port(port)
+
+    process = Process(
+        target=_run_server,
+        args=(fastled_js, port),
+        daemon=True,
+    )
+    process.start()
+    return process

fastled/parse_args.py

@@ -0,0 +1,172 @@
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from fastled import __version__
+from fastled.docker_manager import DockerManager
+from fastled.project_init import project_init
+from fastled.select_sketch_directory import select_sketch_directory
+from fastled.settings import DEFAULT_URL
+from fastled.sketch import (
+    find_sketch_directories,
+    looks_like_fastled_repo,
+    looks_like_sketch_directory,
+)
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description=f"FastLED WASM Compiler {__version__}")
+    parser.add_argument(
+        "--version", action="version", version=f"{__version__}"
+    )
+    parser.add_argument(
+        "directory",
+        type=str,
+        nargs="?",
+        default=None,
+        help="Directory containing the FastLED sketch to compile",
+    )
+    parser.add_argument(
+        "--init",
+        action="store_true",
+        help="Initialize the FastLED sketch in the current directory",
+    )
+    parser.add_argument(
+        "--just-compile",
+        action="store_true",
+        help="Just compile, skip opening the browser and watching for changes.",
+    )
+    parser.add_argument(
+        "--web",
+        "-w",
+        type=str,
+        nargs="?",
+        # const does not seem to be working as expected
+        const=DEFAULT_URL,  # Default value when --web is specified without value
+        help="Use web compiler. Optional URL can be provided (default: https://fastled.onrender.com)",
+    )
+    parser.add_argument(
+        "-i",
+        "--interactive",
+        action="store_true",
+        help="Run in interactive mode (Not available with --web)",
+    )
+    parser.add_argument(
+        "--profile",
+        action="store_true",
+        help="Enable profiling for web compilation",
+    )
+    parser.add_argument(
+        "--force-compile",
+        action="store_true",
+        help="Skips the test to see if the current directory is a valid FastLED sketch directory",
+    )
+    parser.add_argument(
+        "--no-auto-updates",
+        action="store_true",
+        help="Disable automatic updates of the wasm compiler image when using docker.",
+    )
+    parser.add_argument(
+        "--update",
+        "--upgrade",
+        action="store_true",
+        help="Update the wasm compiler (if necessary) before running",
+    )
+    parser.add_argument(
+        "--localhost",
+        "--local",
+        "-l",
+        action="store_true",
+        help="Use localhost for web compilation from an instance of fastled --server, creating it if necessary",
+    )
+    parser.add_argument(
+        "--server",
+        "-s",
+        action="store_true",
+        help="Run the server in the current directory, volume mapping fastled if we are in the repo",
+    )
+
+    build_mode = parser.add_mutually_exclusive_group()
+    build_mode.add_argument("--debug", action="store_true", help="Build in debug mode")
+    build_mode.add_argument(
+        "--quick",
+        action="store_true",
+        default=True,
+        help="Build in quick mode (default)",
+    )
+    build_mode.add_argument(
+        "--release", action="store_true", help="Build in release mode"
+    )
+
+    cwd_is_fastled = looks_like_fastled_repo(Path(os.getcwd()))
+
+    args = parser.parse_args()
+
+    if args.init:
+        args.directory = project_init()
+        print("\nInitialized FastLED project in", args.directory)
+        print(f"Use 'fastled {args.directory}' to compile the project.")
+        sys.exit(0)
+
+    if not args.update:
+        if args.no_auto_updates:
+            args.auto_update = False
+        else:
+            args.auto_update = None
+
+        if (
+            not cwd_is_fastled
+            and not args.localhost
+            and not args.web
+            and not args.server
+        ):
+            if DockerManager.is_docker_installed():
+                if not DockerManager.ensure_linux_containers_for_windows():
+                    print(
+                        f"Windows must be in linux containers mode, but is in Windows container mode, Using web compiler at {DEFAULT_URL}."
+                    )
+                    args.web = DEFAULT_URL
+                else:
+                    print(
+                        "Docker is installed. Defaulting to --local mode, use --web to override and use the web compiler instead."
+                    )
+                    args.localhost = True
+            else:
+                print(f"Docker is not installed. Using web compiler at {DEFAULT_URL}.")
+                args.web = DEFAULT_URL
+        if cwd_is_fastled and not args.web and not args.server:
+            print("Forcing --local mode because we are in the FastLED repo")
+            args.localhost = True
+        if args.localhost:
+            args.web = "localhost"
+        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())
+            if looks_like_sketch_directory(maybe_sketch_dir):
+                args.directory = str(maybe_sketch_dir)
+            else:
+                print("Searching for sketch directories...")
+                sketch_directories = find_sketch_directories(maybe_sketch_dir)
+                selected_dir = select_sketch_directory(
+                    sketch_directories, cwd_is_fastled
+                )
+                if selected_dir:
+                    print(f"Using sketch directory: {selected_dir}")
+                    args.directory = selected_dir
+                else:
+                    print(
+                        "\nYou either need to specify a sketch directory or run in --server mode."
+                    )
+                    sys.exit(1)
+        elif args.directory is not None and os.path.isfile(args.directory):
+            dir_path = Path(args.directory).parent
+            if looks_like_sketch_directory(dir_path):
+                print(f"Using sketch directory: {dir_path}")
+                args.directory = str(dir_path)
+
+    return args

fastled/paths.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+PROJECT_ROOT = HERE.parent.parent

fastled/project_init.py

@@ -0,0 +1,76 @@
+import zipfile
+from pathlib import Path
+
+import httpx
+
+from fastled.settings import DEFAULT_URL
+
+ENDPOINT_PROJECT_INIT = f"{DEFAULT_URL}/project/init"
+ENDPOINT_INFO = f"{DEFAULT_URL}/info"
+DEFAULT_EXAMPLE = "wasm"
+
+
+def get_examples() -> list[str]:
+    response = httpx.get(ENDPOINT_INFO, timeout=4)
+    response.raise_for_status()
+    out: list[str] = response.json()["examples"]
+    return sorted(out)
+
+
+def _prompt_for_example() -> str:
+    examples = get_examples()
+    while True:
+        print("Available examples:")
+        for i, example in enumerate(examples):
+            print(f"  [{i+1}]: {example}")
+        answer = input("Enter the example number or name: ").strip()
+        if answer.isdigit():
+            example_num = int(answer) - 1
+            if example_num < 0 or example_num >= len(examples):
+                print("Invalid example number")
+                continue
+            return examples[example_num]
+        elif answer in examples:
+            return answer
+
+
+def project_init(
+    example: str | None = "PROMPT",  # prompt for example
+    outputdir: Path | None = None,
+    host: str | None = None,
+) -> Path:
+    """
+    Initialize a new FastLED project.
+    """
+    host = host or DEFAULT_URL
+    outputdir = Path(outputdir) if outputdir is not None else Path("fastled")
+    if example == "PROMPT" or example is None:
+        try:
+            example = _prompt_for_example()
+        except httpx.HTTPStatusError:
+            print(
+                f"Failed to fetch examples, using default example '{DEFAULT_EXAMPLE}'"
+            )
+            example = DEFAULT_EXAMPLE
+    assert example is not None
+    endpoint_url = f"{host}/project/init/{example}"
+    response = httpx.get(endpoint_url, timeout=20)
+    response.raise_for_status()
+    content = response.content
+    tmpzip = outputdir / "fastled.zip"
+    outputdir.mkdir(exist_ok=True)
+    tmpzip.write_bytes(content)
+    with zipfile.ZipFile(tmpzip, "r") as zip_ref:
+        zip_ref.extractall(outputdir)
+    tmpzip.unlink()
+    out = outputdir / example
+    assert out.exists()
+    return out
+
+
+def unit_test() -> None:
+    project_init()
+
+
+if __name__ == "__main__":
+    unit_test()