fastled 1.1.15__tar.gz → 1.1.17__tar.gz

{fastled-1.1.15 → fastled-1.1.17}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: fastled
-Version: 1.1.15
+Version: 1.1.17
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
 License: BSD 3-Clause License
 Keywords: template-python-cmd
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: docker
@@ -16,6 +16,8 @@ Requires-Dist: watchdog
 Requires-Dist: livereload
 Requires-Dist: download
 Requires-Dist: filelock
+Requires-Dist: disklru>=2.0.1
+Requires-Dist: appdirs
 
 # FastLED Wasm compiler
 
@@ -159,6 +161,8 @@ A: A big chunk of space is being used by unnecessary javascript `emscripten` is
 
 # Revisions
 
+  * 1.1.17 - Added `--update` and `--no-auto-update` to control whether the compiler in docker mode will try to update.
+  * 1.1.16 - Rewrote docker logic to use container suspension and resumption. Much much faster.
   * 1.1.15 - Fixed logic for considering ipv6 addresses. Auto selection of ipv6 is now restored.
   * 1.1.14 - Fixes for regression in using --server and --localhost as two instances, this is now under test.
   * 1.1.13 - Disable the use of ipv6. It produces random timeouts on the onrender server we are using for the web compiler.

{fastled-1.1.15 → fastled-1.1.17}/README.md

@@ -140,6 +140,8 @@ A: A big chunk of space is being used by unnecessary javascript `emscripten` is
 
 # Revisions
 
+  * 1.1.17 - Added `--update` and `--no-auto-update` to control whether the compiler in docker mode will try to update.
+  * 1.1.16 - Rewrote docker logic to use container suspension and resumption. Much much faster.
   * 1.1.15 - Fixed logic for considering ipv6 addresses. Auto selection of ipv6 is now restored.
   * 1.1.14 - Fixes for regression in using --server and --localhost as two instances, this is now under test.
   * 1.1.13 - Disable the use of ipv6. It produces random timeouts on the onrender server we are using for the web compiler.

{fastled-1.1.15 → fastled-1.1.17}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "fastled"
 readme = "README.md"
 description = "FastLED Wasm Compiler"
-requires-python = ">=3.7"
+requires-python = ">=3.9"
 keywords = ["template-python-cmd"]
 license = { text = "BSD 3-Clause License" }
 classifiers = ["Programming Language :: Python :: 3"]
@@ -17,6 +17,8 @@ dependencies = [
     "livereload",
     "download",
     "filelock",
+    "disklru>=2.0.1",
+    "appdirs",
 ]
 
 dynamic = ["version"]

{fastled-1.1.15 → fastled-1.1.17}/src/fastled/__init__.py

@@ -1,3 +1,3 @@
 """FastLED Wasm Compiler package."""
 
-__version__ = "1.1.15"
+__version__ = "1.1.17"

{fastled-1.1.15 → fastled-1.1.17}/src/fastled/app.py

@@ -44,9 +44,6 @@ class CompiledResult:
     hash_value: str | None
 
 
-DOCKER = DockerManager(container_name=CONTAINER_NAME)
-
-
 def parse_args() -> argparse.Namespace:
     """Parse command-line arguments."""
     parser = argparse.ArgumentParser(description=f"FastLED WASM Compiler {__version__}")
@@ -107,16 +104,32 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Run the server in the current directory, volume mapping fastled if we are in the repo",
     )
-
-    build_mode.add_argument(
+    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",
+        action="store_true",
+        help="Update the wasm compiler (if necessary) before running",
+    )
 
     cwd_is_fastled = looks_like_fastled_repo(Path(os.getcwd()))
 
     args = parser.parse_args()
+    if args.update:
+        args.auto_update = True
+    elif 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:
         print(f"Using web compiler at {DEFAULT_URL}")
         args.web = DEFAULT_URL
@@ -202,8 +215,8 @@ def run_web_compiler(
 
 
 def _try_start_server_or_get_url(args: argparse.Namespace) -> str | CompileServer:
+    auto_update = args.auto_update
     is_local_host = "localhost" in args.web or "127.0.0.1" in args.web or args.localhost
-
     # test to see if there is already a local host server
     local_host_needs_server = False
     if is_local_host:
@@ -228,7 +241,7 @@ def _try_start_server_or_get_url(args: argparse.Namespace) -> str | CompileServe
     else:
         try:
             print("No local server found, starting one...")
-            compile_server = CompileServer()
+            compile_server = CompileServer(auto_updates=auto_update)
             print("Waiting for the local compiler to start...")
             if not compile_server.wait_for_startup():
                 print("Failed to start local compiler.")
@@ -252,7 +265,7 @@ def run_client(args: argparse.Namespace) -> int:
         return 1
 
     # If not explicitly using web compiler, check Docker installation
-    if not args.web and not DOCKER.is_docker_installed():
+    if not args.web and not DockerManager.is_docker_installed():
         print(
             "\nDocker is not installed on this system - switching to web compiler instead."
         )
@@ -304,9 +317,7 @@ def run_client(args: argparse.Namespace) -> int:
         if open_web_browser:
             browser_proc = open_browser_thread(Path(args.directory) / "fastled_js")
         else:
-            print(
-                "\nCompilation successful. Run without --just-compile to open in browser and watch for changes."
-            )
+            print("\nCompilation successful.")
             if compile_server:
                 print("Shutting down compile server...")
                 compile_server.stop()
@@ -402,7 +413,8 @@ def run_client(args: argparse.Namespace) -> int:
 
 def run_server(args: argparse.Namespace) -> int:
     interactive = args.interactive
-    compile_server = CompileServer(interactive=interactive)
+    auto_update = args.auto_update
+    compile_server = CompileServer(interactive=interactive, auto_updates=auto_update)
     if not interactive:
         print(f"Server started at {compile_server.url()}")
     compile_server.wait_for_startup()
@@ -432,9 +444,8 @@ def main() -> int:
 
 if __name__ == "__main__":
     try:
-        # os.chdir("../fastled")
-        sys.argv.append("examples/SdCard")
-        sys.argv.append("--localhost")
+        os.chdir("../fastled")
+        sys.argv.append("--server")
         sys.exit(main())
     except KeyboardInterrupt:
         print("\nExiting from main...")

fastled-1.1.17/src/fastled/compile_server.py

@@ -0,0 +1,158 @@
+import subprocess
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import httpx
+
+from fastled.docker_manager import DISK_CACHE, DockerManager, RunningContainer
+from fastled.sketch import looks_like_fastled_repo
+
+_IMAGE_NAME = "niteris/fastled-wasm"
+_DEFAULT_CONTAINER_NAME = "fastled-wasm-compiler"
+
+SERVER_PORT = 9021
+
+SERVER_OPTIONS = ["--allow-shutdown", "--no-auto-update"]
+
+
+class CompileServer:
+    def __init__(
+        self,
+        container_name=_DEFAULT_CONTAINER_NAME,
+        interactive: bool = False,
+        auto_updates: bool | None = None,
+    ) -> 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()
+        self.fastled_src_dir: Path | None = fastled_src_dir
+        self.interactive = interactive
+        self.running_container: RunningContainer | None = None
+        self.auto_updates = auto_updates
+        self._port = self._start()
+        # fancy print
+        if not interactive:
+            msg = f"# FastLED Compile Server started at {self.url()} #"
+            print("\n" + "#" * len(msg))
+            print(msg)
+            print("#" * len(msg) + "\n")
+
+    @property
+    def running(self) -> bool:
+        if not self._port:
+            return False
+        if not DockerManager.is_docker_installed():
+            return False
+        if not DockerManager.is_running():
+            return False
+        return self.docker.is_container_running(self.container_name)
+
+    def using_fastled_src_dir_volume(self) -> bool:
+        return self.fastled_src_dir is not None
+
+    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.docker.is_container_running(self.container_name):
+                return False
+        return False
+
+    def _start(self) -> int:
+        print("Compiling server starting")
+
+        # Ensure Docker is running
+        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.")
+        now = datetime.now(timezone.utc)
+        now_str = now.strftime("%Y-%m-%d %H %Z")
+
+        upgrade = False
+        if self.auto_updates is None:
+            prev_date_str = DISK_CACHE.get("last-update")
+            if prev_date_str != now_str:
+                print("One hour has passed, checking docker for updates")
+                upgrade = True
+        else:
+            upgrade = self.auto_updates
+        self.docker.validate_or_download_image(
+            image_name=_IMAGE_NAME, tag="main", upgrade=upgrade
+        )
+        DISK_CACHE.put("last-update", now_str)
+
+        print("Docker image now validated")
+        port = SERVER_PORT
+        if self.interactive:
+            server_command = ["/bin/bash"]
+        else:
+            server_command = ["python", "/js/run.py", "server"] + SERVER_OPTIONS
+        server_cmd_str = subprocess.list2cmdline(server_command)
+        print(f"Started Docker container with command: {server_cmd_str}")
+        ports = {80: port}
+        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"}
+            }
+
+        cmd_str = subprocess.list2cmdline(server_command)
+
+        self.docker.run_container(
+            image_name=_IMAGE_NAME,
+            tag="main",
+            container_name=self.container_name,
+            command=cmd_str,
+            ports=ports,
+            volumes=volumes,
+        )
+        self.running_container = self.docker.attach_and_run(self.container_name)
+        assert self.running_container is not None, "Container should be running"
+
+        print("Compile server starting")
+        return port
+
+    def proceess_running(self) -> bool:
+        return self.docker.is_container_running(self.container_name)
+
+    def stop(self) -> None:
+        # print(f"Stopping server on port {self._port}")
+        if self.running_container:
+            self.running_container.stop()
+        self.docker.suspend_container(self.container_name)
+        print("Compile server stopped")