fastled 1.2.23__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,116 @@
+import _thread
+import os
+import select
+import sys
+import time
+from queue import Empty, Queue
+from threading import Thread
+
+_WHITE_SPACE = {" ", "\n", "\r"}  # Including Enter key as whitespace
+
+
+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:
+        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.setcbreak(  # type: ignore
+                    fd
+                )  # Use cbreak mode to avoid console issues # 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 ord(char) == 3:  # Ctrl+C
+                            _thread.interrupt_main()
+                            break
+                        if char in _WHITE_SPACE:
+                            self.queue.put(ord(" "))
+            finally:
+                termios.tcsetattr(  # type: ignore
+                    fd, termios.TCSADRAIN, old_settings  # type: ignore
+                )  # Restore terminal settings
+
+    def space_bar_pressed(self) -> bool:
+        found = False
+        while not self.queue.empty():
+            try:
+                key = self.queue.get(block=False)
+                if key == ord(" "):  # Spacebar
+                    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,86 @@
+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
+
+    def url(self) -> str:
+        """Get the URL of the server."""
+        if isinstance(self.host, CompileServer):
+            return self.host.url()
+        if self.host is None:
+            import warnings
+
+            warnings.warn("TODO: use the actual host.")
+            return "http://localhost:9021"
+        return self.host
+
+    @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
+
+    def __enter__(self) -> "LiveClient":
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        self.finalize()

fastled/open_browser.py

@@ -0,0 +1,161 @@
+import subprocess
+import sys
+import time
+import webbrowser
+from multiprocessing import Process
+from pathlib import Path
+
+DEFAULT_PORT = 8089  # different than live version.
+
+PYTHON_EXE = sys.executable
+
+
+def open_http_server_subprocess(
+    fastled_js: Path, port: int, open_browser: bool
+) -> None:
+    """Start livereload server in the fastled_js directory and return the process"""
+    import shutil
+
+    try:
+        if shutil.which("live-server") is not None:
+            cmd = [
+                "live-server",
+                f"--port={port}",
+                "--host=localhost",
+                ".",
+            ]
+            if not open_browser:
+                cmd.append("--no-browser")
+            subprocess.run(cmd, shell=True, cwd=fastled_js)
+            return
+
+        cmd = [
+            PYTHON_EXE,
+            "-m",
+            "fastled.open_browser2",
+            str(fastled_js),
+            "--port",
+            str(port),
+        ]
+        # return subprocess.Popen(cmd)  # type ignore
+        # pipe stderr and stdout to null
+        subprocess.run(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )  # type ignore
+    except KeyboardInterrupt:
+        import _thread
+
+        _thread.interrupt_main()
+
+
+def is_port_free(port: int) -> bool:
+    """Check if a port is free"""
+    import httpx
+
+    try:
+        response = httpx.get(f"http://localhost:{port}", timeout=1)
+        response.raise_for_status()
+        return False
+    except (httpx.HTTPError, httpx.ConnectError):
+        return True
+
+
+def find_free_port(start_port: int) -> int:
+    """Find a free port starting at start_port"""
+    for port in range(start_port, start_port + 100):
+        if is_port_free(port):
+            print(f"Found free port: {port}")
+            return port
+        else:
+            print(f"Port {port} is in use, finding next")
+    raise ValueError("Could not find a free port")
+
+
+def wait_for_server(port: int, timeout: int = 10) -> None:
+    """Wait for the server to start."""
+    from httpx import get
+
+    future_time = time.time() + timeout
+    while future_time > time.time():
+        try:
+            response = get(f"http://localhost:{port}", timeout=1)
+            if response.status_code == 200:
+                return
+        except Exception:
+            continue
+    raise TimeoutError("Could not connect to server")
+
+
+def _background_npm_install_live_server() -> None:
+    import shutil
+    import time
+
+    if shutil.which("npm") is None:
+        return
+
+    if shutil.which("live-server") is not None:
+        return
+
+    time.sleep(3)
+    subprocess.run(
+        ["npm", "install", "-g", "live-server"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+def open_browser_process(
+    fastled_js: Path, port: int | None = None, open_browser: bool = True
+) -> Process:
+    import shutil
+
+    """Start livereload server in the fastled_js directory and return the process"""
+    if port is not None:
+        if not is_port_free(port):
+            raise ValueError(f"Port {port} was specified but in use")
+    else:
+        port = find_free_port(DEFAULT_PORT)
+    out: Process = Process(
+        target=open_http_server_subprocess,
+        args=(fastled_js, port, False),
+        daemon=True,
+    )
+    out.start()
+    wait_for_server(port)
+    if open_browser:
+        print(f"Opening browser to http://localhost:{port}")
+        webbrowser.open(url=f"http://localhost:{port}", new=1, autoraise=True)
+
+    # start a deamon thread to install live-server
+    if shutil.which("live-server") is None:
+        import threading
+
+        t = threading.Thread(target=_background_npm_install_live_server)
+        t.daemon = True
+        t.start()
+    return out
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Open a browser to the fastled_js directory"
+    )
+    parser.add_argument(
+        "fastled_js",
+        type=Path,
+        help="Path to the fastled_js directory",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=DEFAULT_PORT,
+        help=f"Port to run the server on (default: {DEFAULT_PORT})",
+    )
+    args = parser.parse_args()
+
+    proc = open_browser_process(args.fastled_js, args.port, open_browser=True)
+    proc.join()

fastled/open_browser2.py

@@ -0,0 +1,111 @@
+import argparse
+from pathlib import Path
+
+from livereload import Server
+
+
+def _run_flask_server(fastled_js: Path, port: int) -> None:
+    """Run Flask server with live reload in a subprocess"""
+    try:
+        from flask import Flask, send_from_directory
+
+        app = Flask(__name__)
+
+        # Must be a full path or flask will fail to find the file.
+        fastled_js = fastled_js.resolve()
+
+        @app.route("/")
+        def serve_index():
+            return send_from_directory(fastled_js, "index.html")
+
+        @app.route("/<path:path>")
+        def serve_files(path):
+            response = send_from_directory(fastled_js, path)
+            # Some servers don't set the Content-Type header for a bunch of files.
+            if path.endswith(".js"):
+                response.headers["Content-Type"] = "application/javascript"
+            if path.endswith(".css"):
+                response.headers["Content-Type"] = "text/css"
+            if path.endswith(".wasm"):
+                response.headers["Content-Type"] = "application/wasm"
+            if path.endswith(".json"):
+                response.headers["Content-Type"] = "application/json"
+            if path.endswith(".png"):
+                response.headers["Content-Type"] = "image/png"
+            if path.endswith(".jpg"):
+                response.headers["Content-Type"] = "image/jpeg"
+            if path.endswith(".jpeg"):
+                response.headers["Content-Type"] = "image/jpeg"
+            if path.endswith(".gif"):
+                response.headers["Content-Type"] = "image/gif"
+            if path.endswith(".svg"):
+                response.headers["Content-Type"] = "image/svg+xml"
+            if path.endswith(".ico"):
+                response.headers["Content-Type"] = "image/x-icon"
+            if path.endswith(".html"):
+                response.headers["Content-Type"] = "text/html"
+
+            # now also add headers to force no caching
+            response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
+            response.headers["Pragma"] = "no-cache"
+            response.headers["Expires"] = "0"
+            return response
+
+        server = Server(app.wsgi_app)
+        # Watch index.html for changes
+        server.watch(str(fastled_js / "index.html"))
+        # server.watch(str(fastled_js / "index.js"))
+        # server.watch(str(fastled_js / "index.css"))
+        # Start the server
+        server.serve(port=port, debug=True)
+    except KeyboardInterrupt:
+        import _thread
+
+        _thread.interrupt_main()
+    except Exception as e:
+        print(f"Failed to run Flask server: {e}")
+        import _thread
+
+        _thread.interrupt_main()
+
+
+def run(path: Path, port: int) -> None:
+    """Run the Flask server."""
+    try:
+        _run_flask_server(path, port)
+        import warnings
+
+        warnings.warn("Flask server has stopped")
+    except KeyboardInterrupt:
+        import _thread
+
+        _thread.interrupt_main()
+        pass
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse the command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Open a browser to the fastled_js directory"
+    )
+    parser.add_argument(
+        "fastled_js", type=Path, help="Path to the fastled_js directory"
+    )
+    parser.add_argument(
+        "--port",
+        "-p",
+        type=int,
+        required=True,
+        help="Port to run the server on (default: %(default)s)",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    """Main function."""
+    args = parse_args()
+    run(args.fastled_js, args.port)
+
+
+if __name__ == "__main__":
+    main()