fastled 1.2.33__py3-none-any.whl → 1.4.50__py3-none-any.whl

fastled/client_server.py

@@ -1,22 +1,26 @@
-import argparse
 import shutil
+import sys
 import tempfile
 import threading
 import time
+import traceback
+import warnings
 from multiprocessing import Process
 from pathlib import Path
 
 from fastled.compile_server import CompileServer
 from fastled.docker_manager import DockerManager
-from fastled.filewatcher import FileWatcherProcess
+from fastled.emoji_util import EMO
+from fastled.filewatcher import DebouncedFileWatcherProcess, FileWatcherProcess
+from fastled.find_good_connection import ConnectionResult
 from fastled.keyboard import SpaceBarWatcher
-from fastled.open_browser import open_browser_process
-from fastled.settings import DEFAULT_URL
+from fastled.open_browser import spawn_http_server
+from fastled.parse_args import Args
+from fastled.settings import DEFAULT_URL, IMAGE_NAME
 from fastled.sketch import looks_like_sketch_directory
 from fastled.types import BuildMode, CompileResult, CompileServerError
 from fastled.web_compile import (
     SERVER_PORT,
-    ConnectionResult,
     find_good_connection,
     web_compile,
 )
@@ -62,38 +66,116 @@ def TEST_BEFORE_COMPILE(url) -> None:
     pass
 
 
+def _chunked_print(stdout: str) -> None:
+    lines = stdout.splitlines()
+    for line in lines:
+        try:
+            print(line)
+        except UnicodeEncodeError:
+            # On Windows, the console may not support Unicode characters
+            # Try to encode the line with the console's encoding and replace problematic characters
+            try:
+                console_encoding = sys.stdout.encoding or "utf-8"
+                encoded_line = line.encode(console_encoding, errors="replace").decode(
+                    console_encoding
+                )
+                print(encoded_line)
+            except Exception:
+                # If all else fails, just print the line without problematic characters
+                print(line.encode("ascii", errors="replace").decode("ascii"))
+
+
 def _run_web_compiler(
     directory: Path,
     host: str,
     build_mode: BuildMode,
     profile: bool,
     last_hash_value: str | None,
+    no_platformio: bool = False,
+    allow_libcompile: bool = False,
 ) -> CompileResult:
+    # Remove the import and libcompile detection logic from here
+    # since it will now be passed as a parameter
     input_dir = Path(directory)
     output_dir = input_dir / "fastled_js"
+
+    # Guard: libfastled compilation requires volume source mapping
+    if not allow_libcompile:
+        print(f"{EMO('⚠️', 'WARNING:')}  libfastled compilation disabled.")
+
     start = time.time()
     web_result = web_compile(
-        directory=input_dir, host=host, build_mode=build_mode, profile=profile
+        directory=input_dir,
+        host=host,
+        build_mode=build_mode,
+        profile=profile,
+        no_platformio=no_platformio,
+        allow_libcompile=allow_libcompile,
     )
     diff = time.time() - start
     if not web_result.success:
         print("\nWeb compilation failed:")
         print(f"Time taken: {diff:.2f} seconds")
-        print(web_result.stdout)
+        _chunked_print(web_result.stdout)
         # Create error page
         output_dir.mkdir(exist_ok=True)
         error_html = _create_error_html(web_result.stdout)
         (output_dir / "index.html").write_text(error_html, encoding="utf-8")
         return web_result
 
+    # Extract zip contents to fastled_js directory
+    extraction_start_time = time.time()
+    output_dir.mkdir(exist_ok=True)
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+        temp_zip = temp_path / "result.zip"
+        temp_zip.write_bytes(web_result.zip_bytes)
+
+        # Clear existing contents
+        shutil.rmtree(output_dir, ignore_errors=True)
+        output_dir.mkdir(exist_ok=True)
+
+        # Extract zip contents
+        shutil.unpack_archive(temp_zip, output_dir, "zip")
+    extraction_time = time.time() - extraction_start_time
+
     def print_results() -> None:
         hash_value = (
             web_result.hash_value
             if web_result.hash_value is not None
             else "NO HASH VALUE"
         )
+
+        # Build timing breakdown
+        timing_breakdown = f"  Time: {diff:.2f} (seconds)"
+        if hasattr(web_result, "zip_time"):
+            timing_breakdown += f"\n     zip creation: {web_result.zip_time:.2f}"
+            if web_result.libfastled_time > 0:
+                timing_breakdown += (
+                    f"\n     libfastled: {web_result.libfastled_time:.2f}"
+                )
+            timing_breakdown += (
+                f"\n     sketch compile + link: {web_result.sketch_time:.2f}"
+            )
+            if hasattr(web_result, "response_processing_time"):
+                timing_breakdown += f"\n     response processing: {web_result.response_processing_time:.2f}"
+
+            # Calculate any unaccounted time
+            accounted_time = (
+                web_result.zip_time
+                + web_result.libfastled_time
+                + web_result.sketch_time
+                + web_result.response_processing_time
+                + extraction_time
+            )
+            unaccounted_time = diff - accounted_time
+            if extraction_time > 0.01:
+                timing_breakdown += f"\n     extraction: {extraction_time:.2f}"
+            if unaccounted_time > 0.01:
+                timing_breakdown += f"\n     other overhead: {unaccounted_time:.2f}"
+
         print(
-            f"\nWeb compilation successful\n  Time: {diff:.2f}\n  output: {output_dir}\n  hash: {hash_value}\n  zip size: {len(web_result.zip_bytes)} bytes"
+            f"\nWeb compilation successful\n{timing_breakdown}\n  output: {output_dir}\n  hash: {hash_value}\n  zip size: {len(web_result.zip_bytes)} bytes"
         )
 
     # now check to see if the hash value is the same as the last hash value
@@ -102,27 +184,17 @@ def _run_web_compiler(
         print_results()
         return web_result
 
-    # Extract zip contents to fastled_js directory
-    output_dir.mkdir(exist_ok=True)
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-        temp_zip = temp_path / "result.zip"
-        temp_zip.write_bytes(web_result.zip_bytes)
-
-        # Clear existing contents
-        shutil.rmtree(output_dir, ignore_errors=True)
-        output_dir.mkdir(exist_ok=True)
-
-        # Extract zip contents
-        shutil.unpack_archive(temp_zip, output_dir, "zip")
-
-    print(web_result.stdout)
+    _chunked_print(web_result.stdout)
     print_results()
     return web_result
 
 
 def _try_start_server_or_get_url(
-    auto_update: bool, args_web: str | bool, localhost: bool
+    auto_update: bool,
+    args_web: str | bool,
+    localhost: bool,
+    clear: bool,
+    no_platformio: bool = False,
 ) -> tuple[str, CompileServer | None]:
     is_local_host = localhost or (
         isinstance(args_web, str)
@@ -132,9 +204,9 @@ def _try_start_server_or_get_url(
     local_host_needs_server = False
     if is_local_host:
         addr = "localhost" if localhost or not isinstance(args_web, str) else args_web
-        urls = [addr]
         if ":" not in addr:
-            urls.append(f"{addr}:{SERVER_PORT}")
+            addr = f"{addr}:{SERVER_PORT}"
+        urls = [addr]
 
         result: ConnectionResult | None = find_good_connection(urls)
         if result is not None:
@@ -152,7 +224,11 @@ def _try_start_server_or_get_url(
     else:
         try:
             print("No local server found, starting one...")
-            compile_server = CompileServer(auto_updates=auto_update)
+            compile_server = CompileServer(
+                auto_updates=auto_update,
+                remove_previous=clear,
+                no_platformio=no_platformio,
+            )
             print("Waiting for the local compiler to start...")
             if not compile_server.ping():
                 print("Failed to start local compiler.")
@@ -160,11 +236,83 @@ def _try_start_server_or_get_url(
             return (compile_server.url(), compile_server)
         except KeyboardInterrupt:
             raise
-        except RuntimeError:
-            print("Failed to start local compile server, using web compiler instead.")
+        except Exception as e:
+            warnings.warn(
+                f"Failed to start local compile server because of {e}, using web compiler instead."
+            )
             return (DEFAULT_URL, None)
 
 
+def _try_make_compile_server(
+    clear: bool = False, no_platformio: bool = False
+) -> CompileServer | None:
+    if not DockerManager.is_docker_installed():
+        return None
+    try:
+        print(
+            "\nNo host specified, but Docker is installed, attempting to start a compile server using Docker."
+        )
+        from fastled.util import find_free_port
+
+        free_port = find_free_port(start_port=9723, end_port=9743)
+        if free_port is None:
+            return None
+        compile_server = CompileServer(
+            auto_updates=False, remove_previous=clear, no_platformio=no_platformio
+        )
+        print("Waiting for the local compiler to start...")
+        if not compile_server.ping():
+            print("Failed to start local compiler.")
+            raise CompileServerError("Failed to start local compiler.")
+        return compile_server
+    except KeyboardInterrupt:
+        import _thread
+
+        _thread.interrupt_main()
+        raise
+    except Exception as e:
+        warnings.warn(f"Error starting local compile server: {e}")
+        return None
+
+
+def _background_update_docker_image() -> None:
+    """Perform docker image update in the background silently."""
+    try:
+        # Only attempt update if Docker is installed and running
+        if not DockerManager.is_docker_installed():
+            return
+
+        docker_manager = DockerManager()
+        docker_running, _ = docker_manager.is_running()
+        if not docker_running:
+            return
+
+        # Silently update the docker image
+        docker_manager.validate_or_download_image(
+            image_name=IMAGE_NAME, tag="latest", upgrade=True
+        )
+    except KeyboardInterrupt:
+        import _thread
+
+        _thread.interrupt_main()
+    except Exception as e:
+        # Log warning but don't disrupt user experience
+        import warnings
+
+        warnings.warn(f"Background docker image update failed: {e}")
+
+
+def _is_local_host(url: str) -> bool:
+    return (
+        url.startswith("http://localhost")
+        or url.startswith("http://127.0.0.1")
+        or url.startswith("http://0.0.0.0")
+        or url.startswith("http://[::]")
+        or url.startswith("http://[::1]")
+        or url.startswith("http://[::ffff:127.0.0.1]")
+    )
+
+
 def run_client(
     directory: Path,
     host: str | CompileServer | None,
@@ -173,14 +321,32 @@ def run_client(
     build_mode: BuildMode = BuildMode.QUICK,
     profile: bool = False,
     shutdown: threading.Event | None = None,
+    http_port: (
+        int | None
+    ) = None,  # None means auto select a free port, http_port < 0 means no server.
+    clear: bool = False,
+    no_platformio: bool = False,
+    app: bool = False,  # Use app-like browser experience
+    background_update: bool = False,
+    enable_https: bool = True,  # Enable HTTPS for the local server
 ) -> int:
+    has_checked_newer_version_yet = False
+    compile_server: CompileServer | None = None
+
+    if host is None:
+        # attempt to start a compile server if docker is installed.
+        compile_server = _try_make_compile_server(
+            clear=clear, no_platformio=no_platformio
+        )
+        if compile_server is None:
+            host = DEFAULT_URL
+    elif isinstance(host, CompileServer):
+        # if the host is a compile server, use that
+        compile_server = host
 
-    compile_server: CompileServer | None = (
-        host if isinstance(host, CompileServer) else None
-    )
     shutdown = shutdown or threading.Event()
 
-    def get_url() -> str:
+    def get_url(host=host, compile_server=compile_server) -> str:
         if compile_server is not None:
             return compile_server.url()
         if isinstance(host, str):
@@ -188,6 +354,26 @@ def run_client(
         return DEFAULT_URL
 
     url = get_url()
+    is_local_host = _is_local_host(url)
+    # parse out the port from the url
+    # use a standard host address parser to grab it
+    import urllib.parse
+
+    parsed_url = urllib.parse.urlparse(url)
+    if parsed_url.port is not None:
+        port = parsed_url.port
+    else:
+        if is_local_host:
+            raise ValueError(
+                "Cannot use local host without a port. Please specify a port."
+            )
+        # Assume default port for www
+        port = 80
+
+    # Auto-detect libcompile capability on first call
+    from fastled.sketch import looks_like_fastled_repo
+
+    allow_libcompile = is_local_host and looks_like_fastled_repo(Path(".").resolve())
 
     try:
 
@@ -196,6 +382,8 @@ def run_client(
             build_mode: BuildMode = build_mode,
             profile: bool = profile,
             last_hash_value: str | None = None,
+            no_platformio: bool = no_platformio,
+            allow_libcompile: bool = allow_libcompile,
         ) -> CompileResult:
             TEST_BEFORE_COMPILE(url)
             return _run_web_compiler(
@@ -204,6 +392,8 @@ def run_client(
                 build_mode=build_mode,
                 profile=profile,
                 last_hash_value=last_hash_value,
+                no_platformio=no_platformio,
+                allow_libcompile=allow_libcompile,
             )
 
         result: CompileResult = compile_function(last_hash_value=None)
@@ -212,39 +402,67 @@ def run_client(
         if not result.success:
             print("\nCompilation failed.")
 
-        browser_proc: Process | None = None
-        if open_web_browser:
-            browser_proc = open_browser_process(directory / "fastled_js")
+        use_http_server = http_port is None or http_port >= 0
+        if not use_http_server and open_web_browser:
+            warnings.warn(
+                f"Warning: --http-port={http_port} specified but open_web_browser is False, ignoring --http-port."
+            )
+            use_http_server = False
+
+        http_proc: Process | None = None
+        if use_http_server:
+            http_proc = spawn_http_server(
+                directory / "fastled_js",
+                port=http_port,
+                compile_server_port=port,
+                open_browser=open_web_browser,
+                app=app,
+                enable_https=enable_https,
+            )
         else:
-            print("\nCompilation successful.")
+            if result.success:
+                print("\nCompilation successful.")
+            else:
+                print("\nCompilation failed.")
             if compile_server:
                 print("Shutting down compile server...")
                 compile_server.stop()
-            return 0
+            return 0 if result.success else 1
 
         if not keep_running or shutdown.is_set():
-            if browser_proc:
-                browser_proc.kill()
+            if http_proc:
+                http_proc.kill()
             return 0 if result.success else 1
     except KeyboardInterrupt:
         print("\nExiting from main")
         return 1
 
-    sketch_filewatcher = FileWatcherProcess(directory, excluded_patterns=["fastled_js"])
+    excluded_patterns = ["fastled_js"]
+    debounced_sketch_watcher = DebouncedFileWatcherProcess(
+        FileWatcherProcess(directory, excluded_patterns=excluded_patterns),
+    )
 
     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=[]
+            compile_server.fastled_src_dir, excluded_patterns=excluded_patterns
         )
 
     def trigger_rebuild_if_sketch_changed(
         last_compiled_result: CompileResult,
     ) -> tuple[bool, CompileResult]:
-        changed_files = sketch_filewatcher.get_all_changes()
+        changed_files = debounced_sketch_watcher.get_all_changes()
         if changed_files:
-            print(f"\nChanges detected in {changed_files}")
+            # Filter out any fastled_js changes that slipped through
+            sketch_changes = [
+                f for f in changed_files if "fastled_js" not in Path(f).parts
+            ]
+            if not sketch_changes:
+                # All changes were in fastled_js, ignore them
+                return False, last_compiled_result
+            print(f"\nChanges detected in {sketch_changes}")
+            print("Compiling...")
             last_hash_value = last_compiled_result.hash_value
             out = compile_function(last_hash_value=last_hash_value)
             if not out.success:
@@ -265,6 +483,40 @@ def run_client(
             if shutdown.is_set():
                 print("\nStopping watch mode...")
                 return 0
+
+            # Check for newer Docker image version after first successful compilation
+            if (
+                not has_checked_newer_version_yet
+                and last_compiled_result.success
+                and is_local_host
+            ):
+                has_checked_newer_version_yet = True
+                try:
+
+                    docker_manager = DockerManager()
+                    has_update, message = docker_manager.has_newer_version(
+                        image_name=IMAGE_NAME, tag="latest"
+                    )
+                    if has_update:
+                        print(f"\n🔄 {message}")
+                        if background_update:
+                            # Start background update in a separate thread
+                            update_thread = threading.Thread(
+                                target=_background_update_docker_image, daemon=True
+                            )
+                            update_thread.start()
+                            background_update = False
+                        else:
+                            print(
+                                "Run with `fastled -u` to update the docker image to the latest version."
+                            )
+                            print(
+                                "Or use `--background-update` to update automatically in the background after compilation."
+                            )
+                except Exception as e:
+                    # Don't let Docker check failures interrupt the main flow
+                    warnings.warn(f"Failed to check for Docker image updates: {e}")
+
             if SpaceBarWatcher.watch_space_bar_pressed(timeout=1.0):
                 print("Compiling...")
                 last_compiled_result = compile_function(last_hash_value=None)
@@ -292,17 +544,22 @@ def run_client(
                 if changed_files:
                     print(f"\nChanges detected in FastLED source code: {changed_files}")
                     print("Press space bar to trigger compile.")
+
                     while True:
                         space_bar_pressed = SpaceBarWatcher.watch_space_bar_pressed(
                             timeout=1.0
                         )
                         file_changes = source_code_watcher.get_all_changes()
-                        sketch_files_changed = sketch_filewatcher.get_all_changes()
+                        sketch_files_changed = (
+                            debounced_sketch_watcher.get_all_changes()
+                        )
 
                         if file_changes:
                             print(
                                 f"Changes detected in {file_changes}\nHit the space bar to trigger compile."
                             )
+                            # Re-evaluate libcompile capability when source code changes
+                            allow_libcompile = True
 
                         if space_bar_pressed or sketch_files_changed:
                             if space_bar_pressed:
@@ -312,7 +569,10 @@ def run_client(
                                     f"Changes detected in {','.join(sketch_files_changed)}, triggering recompile..."
                                 )
                             last_compiled_result = compile_function(
-                                last_hash_value=None
+                                last_hash_value=None, allow_libcompile=allow_libcompile
+                            )
+                            allow_libcompile = (
+                                allow_libcompile and not last_compiled_result.success
                             )
                             print("Finished recompile.")
                             # Drain the space bar queue
@@ -327,24 +587,27 @@ def run_client(
         print(f"Error: {e}")
         return 1
     finally:
-        sketch_filewatcher.stop()
+        debounced_sketch_watcher.stop()
         if compile_server:
             compile_server.stop()
-        if browser_proc:
-            browser_proc.kill()
+        if http_proc:
+            http_proc.kill()
 
 
-def run_client_server(args: argparse.Namespace) -> int:
+def run_client_server(args: Args) -> int:
     profile = bool(args.profile)
     web: str | bool = args.web if isinstance(args.web, str) else bool(args.web)
     auto_update = bool(args.auto_update)
+    background_update = bool(args.background_update)
     localhost = bool(args.localhost)
-    directory = Path(args.directory)
+    directory = args.directory if args.directory else Path(".")
     just_compile = bool(args.just_compile)
     interactive = bool(args.interactive)
     force_compile = bool(args.force_compile)
     open_web_browser = not just_compile and not interactive
     build_mode: BuildMode = BuildMode.from_args(args)
+    no_platformio = bool(args.no_platformio)
+    app = bool(args.app)
 
     if not force_compile and not looks_like_sketch_directory(directory):
         # if there is only one directory in the sketch directory, use that
@@ -373,15 +636,27 @@ def run_client_server(args: argparse.Namespace) -> int:
     url: str
     compile_server: CompileServer | None = None
     try:
-        url, compile_server = _try_start_server_or_get_url(auto_update, web, localhost)
+        url, compile_server = _try_start_server_or_get_url(
+            auto_update, web, localhost, args.clear, no_platformio
+        )
     except KeyboardInterrupt:
         print("\nExiting from first try...")
-        if compile_server:
+        if compile_server is not None:
             compile_server.stop()
         return 1
     except Exception as e:
-        print(f"Error: {e}")
-        if compile_server:
+        stack_trace = e.__traceback__
+        stack_trace_list: list[str] | None = (
+            traceback.format_exception(type(e), e, stack_trace) if stack_trace else None
+        )
+        stack_trace_str = ""
+        if stack_trace_list is not None:
+            stack_trace_str = "".join(stack_trace_list) if stack_trace_list else ""
+        if stack_trace:
+            print(f"Error in starting compile server: {e}\n{stack_trace_str}")
+        else:
+            print(f"Error: {e}")
+        if compile_server is not None:
             compile_server.stop()
         return 1
 
@@ -393,6 +668,10 @@ def run_client_server(args: argparse.Namespace) -> int:
             keep_running=not just_compile,
             build_mode=build_mode,
             profile=profile,
+            clear=args.clear,
+            no_platformio=no_platformio,
+            app=app,
+            background_update=background_update,
         )
     except KeyboardInterrupt:
         return 1

fastled/compile_server.py

@@ -15,6 +15,8 @@ class CompileServer:
         container_name: str | None = None,
         platform: Platform = Platform.WASM,
         remove_previous: bool = False,
+        no_platformio: bool = False,
+        allow_libcompile: bool = True,
     ) -> None:
         from fastled.compile_server_impl import (  # avoid circular import
             CompileServerImpl,
@@ -29,6 +31,8 @@ class CompileServer:
             mapped_dir=mapped_dir,
             auto_start=auto_start,
             remove_previous=remove_previous,
+            no_platformio=no_platformio,
+            allow_libcompile=allow_libcompile,
         )
 
     # May throw CompileServerError if server could not be started.
@@ -59,7 +63,8 @@ class CompileServer:
 
     @property
     def running(self) -> bool:
-        return self.impl.running
+        ok, _ = self.impl.running
+        return ok
 
     @property
     def fastled_src_dir(self) -> Path | None:
@@ -96,3 +101,9 @@ class CompileServer:
 
     def process_running(self) -> bool:
         return self.impl.process_running()
+
+    def get_emsdk_headers(self, filepath: Path) -> None:
+        """Get EMSDK headers ZIP data from the server and save to filepath."""
+        if not str(filepath).endswith(".zip"):
+            raise ValueError("Filepath must end with .zip")
+        return self.impl.get_emsdk_headers(filepath)