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

fastled/compile_server_impl.py

@@ -1,6 +1,7 @@
 import subprocess
 import sys
 import time
+import traceback
 import warnings
 from datetime import datetime, timezone
 from pathlib import Path
@@ -12,16 +13,23 @@ from fastled.docker_manager import (
     Container,
     DockerManager,
     RunningContainer,
+    Volume,
 )
+from fastled.emoji_util import EMO
 from fastled.settings import DEFAULT_CONTAINER_NAME, IMAGE_NAME, SERVER_PORT
 from fastled.sketch import looks_like_fastled_repo
 from fastled.types import BuildMode, CompileResult, CompileServerError
+from fastled.util import port_is_free, print_banner
 
 SERVER_OPTIONS = [
     "--allow-shutdown",  # Allow the server to be shut down without a force kill.
     "--no-auto-update",  # Don't auto live updates from the git repo.
 ]
 
+LOCAL_DOCKER_ENV = {
+    "ONLY_QUICK_BUILDS": "0"  # When running docker always allow release and debug.
+}
+
 
 def _try_get_fastled_src(path: Path) -> Path | None:
     fastled_src_dir: Path | None = None
@@ -43,6 +51,8 @@ class CompileServerImpl:
         auto_start: bool = True,
         container_name: str | None = None,
         remove_previous: bool = False,
+        no_platformio: bool = False,
+        allow_libcompile: bool = True,
     ) -> None:
         container_name = container_name or DEFAULT_CONTAINER_NAME
         if interactive and not mapped_dir:
@@ -61,6 +71,18 @@ class CompileServerImpl:
         self.running_container: RunningContainer | None = None
         self.auto_updates = auto_updates
         self.remove_previous = remove_previous
+        self.no_platformio = no_platformio
+
+        # Guard: libfastled compilation requires volume source mapping
+        # If we don't have fastled_src_dir (not in FastLED repo), disable libcompile
+        if allow_libcompile and self.fastled_src_dir is None:
+            print(
+                f"{EMO('⚠️', 'WARNING:')}  libfastled compilation disabled: volume source mapping not available"
+            )
+            print("   (not running in FastLED repository)")
+            allow_libcompile = False
+
+        self.allow_libcompile = allow_libcompile
         self._port = 0  # 0 until compile server is started
         if auto_start:
             self.start()
@@ -98,7 +120,12 @@ class CompileServerImpl:
         if not self.ping():
             raise RuntimeError("Server is not running")
         out: CompileResult = web_compile(
-            directory, host=self.url(), build_mode=build_mode, profile=profile
+            directory,
+            host=self.url(),
+            build_mode=build_mode,
+            profile=profile,
+            no_platformio=self.no_platformio,
+            allow_libcompile=self.allow_libcompile,
         )
         return out
 
@@ -110,14 +137,24 @@ class CompileServerImpl:
         project_init(example=example, outputdir=outputdir)
 
     @property
-    def running(self) -> bool:
+    def running(self) -> tuple[bool, Exception | None]:
         if not self._port:
-            return False
+            return False, Exception("Docker hasn't been initialzed with a port yet")
         if not DockerManager.is_docker_installed():
-            return False
-        if not DockerManager.is_running():
-            return False
-        return self.docker.is_container_running(self.container_name)
+            return False, Exception("Docker is not installed")
+        docker_running, err = self.docker.is_running()
+        if not docker_running:
+            IS_MAC = sys.platform == "darwin"
+            if IS_MAC:
+                if "FileNotFoundError" in str(err):
+                    traceback.print_exc()
+                    print("\n\nNone fatal debug print for MacOS\n")
+            return False, err
+        ok: bool = self.docker.is_container_running(self.container_name)
+        if ok:
+            return True, None
+        else:
+            return False, Exception("Docker is not running")
 
     def using_fastled_src_dir_volume(self) -> bool:
         out = self.fastled_src_dir is not None
@@ -170,7 +207,10 @@ class CompileServerImpl:
         print("Compiling server starting")
 
         # Ensure Docker is running
-        if not self.docker.is_running():
+        running: bool
+        # err: Exception | None
+        running, _ = self.docker.is_running()
+        if not running:
             if not self.docker.start():
                 print("Docker could not be started. Exiting.")
                 raise RuntimeError("Docker could not be started. Exiting.")
@@ -185,10 +225,11 @@ class CompileServerImpl:
                 upgrade = True
         else:
             upgrade = self.auto_updates
-        self.docker.validate_or_download_image(
-            image_name=IMAGE_NAME, tag="main", upgrade=upgrade
+        updated = self.docker.validate_or_download_image(
+            image_name=IMAGE_NAME, tag="latest", upgrade=upgrade
         )
         DISK_CACHE.put("last-update", now_str)
+        INTERNAL_DOCKER_PORT = 80
 
         print("Docker image now validated")
         port = SERVER_PORT
@@ -196,71 +237,90 @@ class CompileServerImpl:
             server_command = ["/bin/bash"]
         else:
             server_command = ["python", "/js/run.py", "server"] + SERVER_OPTIONS
-        ports = {80: port}
-        volumes = None
+            if self.no_platformio:
+                server_command.append("--no-platformio")
+        if self.interactive:
+            print("Disabling port forwarding in interactive mode")
+            ports = {}
+        else:
+            ports = {INTERNAL_DOCKER_PORT: port}
+        volumes = []
         if self.fastled_src_dir:
-            print(
-                f"Mounting FastLED source directory {self.fastled_src_dir} into container /host/fastled/src"
+            msg = f"FastLED REPO updates enabled!!\n\nMounting FastLED source directory\n{self.fastled_src_dir} into container\n/host/fastled/src"
+            print_banner(msg)
+            volumes.append(
+                Volume(
+                    host_path=str(self.fastled_src_dir),
+                    container_path="/host/fastled/src",
+                    mode="ro",
+                )
             )
-            volumes = {
-                str(self.fastled_src_dir): {"bind": "/host/fastled/src", "mode": "ro"}
-            }
         if self.interactive:
             # add the mapped directory to the container
             print(f"Mounting {self.mapped_dir} into container /mapped")
-            # volumes = {str(self.mapped_dir): {"bind": "/mapped", "mode": "rw"}}
-            # add it
             assert self.mapped_dir is not None
             dir_name = self.mapped_dir.name
             if not volumes:
-                volumes = {}
-            volumes[str(self.mapped_dir)] = {
-                "bind": f"/mapped/{dir_name}",
-                "mode": "rw",
-            }
+                volumes = []
+            volumes.append(
+                Volume(
+                    host_path=str(self.mapped_dir),
+                    container_path=f"/mapped/{dir_name}",
+                    mode="rw",
+                )
+            )
             if self.fastled_src_dir is not None:
-                # add volume for src/platforms/wasm/compiler/CMakelists.txt
                 # to allow for interactive compilation
-                interactive_sources = [
-                    "src/platforms/wasm/compiler/CMakeLists.txt",
-                    "src/platforms/wasm/compiler/build_archive.sh",
-                ]
-                for src in interactive_sources:
-                    src_path = Path(src).absolute()
+                # interactive_sources = list(INTERACTIVE_SOURCES)
+                interactive_sources: list[tuple[Path, str]] = []
+                src_host: Path
+                dst_container: str
+                for src_host, dst_container in interactive_sources:
+                    src_path = Path(src_host).absolute()
                     if src_path.exists():
-                        print(f"Mounting {src} into container")
-                        src_str = str(src_path)
-                        volumes[src_str] = {
-                            "bind": f"/js/fastled/{src}",
-                            "mode": "rw",
-                        }
+                        print(f"Mounting {src_host} into container")
+                        volumes.append(
+                            Volume(
+                                host_path=str(src_path),
+                                container_path=dst_container,
+                                mode="rw",
+                            )
+                        )
                     else:
-                        print(f"Could not find {src}")
+                        print(f"Could not find {src_path}")
 
         cmd_str = subprocess.list2cmdline(server_command)
         if not self.interactive:
             container: Container = self.docker.run_container_detached(
                 image_name=IMAGE_NAME,
-                tag="main",
+                tag="latest",
                 container_name=self.container_name,
                 command=cmd_str,
                 ports=ports,
                 volumes=volumes,
-                remove_previous=self.interactive or self.remove_previous,
+                remove_previous=self.interactive or self.remove_previous or updated,
+                environment=LOCAL_DOCKER_ENV,
             )
             self.running_container = self.docker.attach_and_run(container)
             assert self.running_container is not None, "Container should be running"
             print("Compile server starting")
             return port
         else:
-
+            client_port_mapped = INTERNAL_DOCKER_PORT in ports
+            free_port = port_is_free(INTERNAL_DOCKER_PORT)
+            if client_port_mapped and free_port:
+                warnings.warn(
+                    f"Can't expose port {INTERNAL_DOCKER_PORT}, disabling port forwarding in interactive mode"
+                )
+                ports = {}
             self.docker.run_container_interactive(
                 image_name=IMAGE_NAME,
-                tag="main",
+                tag="latest",
                 container_name=self.container_name,
                 command=cmd_str,
                 ports=ports,
                 volumes=volumes,
+                environment=LOCAL_DOCKER_ENV,
             )
 
             print("Exiting interactive mode")
@@ -270,9 +330,22 @@ class CompileServerImpl:
         return self.docker.is_container_running(self.container_name)
 
     def stop(self) -> None:
+        if self.docker.is_suspended:
+            return
         if self.running_container:
             self.running_container.detach()
             self.running_container = None
         self.docker.suspend_container(self.container_name)
         self._port = 0
         print("Compile server stopped")
+
+    def get_emsdk_headers(self, filepath: Path) -> None:
+        """Get EMSDK headers ZIP data from the server and save to filepath."""
+        from fastled.util import download_emsdk_headers
+
+        if not self._port:
+            raise RuntimeError("Server has not been started yet")
+        if not self.ping():
+            raise RuntimeError("Server is not running")
+
+        download_emsdk_headers(self.url(), filepath)