fastled 1.1.15__py2.py3-none-any.whl → 1.1.16__py2.py3-none-any.whl

fastled/__init__.py

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

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__}")
@@ -252,7 +249,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 +301,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()
@@ -432,9 +427,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/compile_server.py

@@ -1,13 +1,13 @@
-import socket
 import subprocess
 import time
 from pathlib import Path
 
 import httpx
 
-from fastled.docker_manager import DockerManager
+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
@@ -15,19 +15,6 @@ SERVER_PORT = 9021
 SERVER_OPTIONS = ["--allow-shutdown", "--no-auto-update"]
 
 
-def find_available_port(start_port: int = SERVER_PORT) -> int:
-    """Find an available port starting from the given port."""
-    port = start_port
-    end_port = start_port + 1000
-    while True:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            if s.connect_ex(("localhost", port)) != 0:
-                return port
-            port += 1
-            if port >= end_port:
-                raise RuntimeError("No available ports found")
-
-
 class CompileServer:
     def __init__(
         self,
@@ -44,11 +31,10 @@ class CompileServer:
             fastled_src_dir = cwd / "src"
 
         self.container_name = container_name
-        self.docker = DockerManager(container_name=container_name)
-        self.running = False
-        self.running_process: subprocess.Popen | None = None
+        self.docker = DockerManager()
         self.fastled_src_dir: Path | None = fastled_src_dir
         self.interactive = interactive
+        self.running_container: RunningContainer | None = None
         self._port = self._start()
         # fancy print
         if not interactive:
@@ -57,6 +43,16 @@ class CompileServer:
             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
 
@@ -86,56 +82,44 @@ class CompileServer:
             except Exception:
                 pass
             time.sleep(0.1)
-            if not self.running:
+            if not self.docker.is_container_running(self.container_name):
                 return False
         return False
 
     def _start(self) -> int:
         print("Compiling server starting")
-        self.running = True
+
         # Ensure Docker is running
         with self.docker.get_lock():
             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.")
+            from datetime import datetime, timezone
 
-            # Clean up any existing container with the same name
-            try:
-                container_exists = (
-                    subprocess.run(
-                        ["docker", "inspect", self.container_name],
-                        capture_output=True,
-                        text=True,
-                    ).returncode
-                    == 0
-                )
-                if container_exists:
-                    print("Cleaning up existing container")
-                    subprocess.run(
-                        ["docker", "rm", "-f", self.container_name],
-                        check=False,
-                    )
-            except KeyboardInterrupt:
-                raise
-            except Exception as e:
-                print(f"Warning: Failed to remove existing container: {e}")
+            now = datetime.now(timezone.utc)
+            now_str = now.strftime("%Y-%m-%d %H %Z")
+            prev_date_str = DISK_CACHE.get("last-update")
+
+            upgrade = False
+            if prev_date_str != now_str:
+                print("New day, upgrading Docker image")
+                upgrade = True
 
-            print("Ensuring Docker image exists at latest version")
-            if not self.docker.ensure_image_exists():
-                print("Failed to ensure Docker image exists.")
-                raise RuntimeError("Failed to ensure Docker image exists")
+            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 = find_available_port()
-        print(f"Found an available port: {port}")
+        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 = {port: 80}
+        ports = {80: port}
         volumes = None
         if self.fastled_src_dir:
             print(
@@ -144,78 +128,29 @@ class CompileServer:
             volumes = {
                 str(self.fastled_src_dir): {"bind": "/host/fastled/src", "mode": "ro"}
             }
-        self.running_process = self.docker.run_container(
-            server_command, ports=ports, volumes=volumes, tty=self.interactive
+
+        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")
-        time.sleep(3)
-        if self.running_process.poll() is not None:
-            print("Server failed to start")
-            self.running = False
-            raise RuntimeError("Server failed to start")
         return port
 
     def proceess_running(self) -> bool:
-        if self.running_process is None:
-            return False
-        return self.running_process.poll() is None
+        return self.docker.is_container_running(self.container_name)
 
     def stop(self) -> None:
-        print(f"Stopping server on port {self._port}")
-        # # attempt to send a shutdown signal to the server
-        # try:
-        #     httpx.get(f"http://localhost:{self._port}/shutdown", timeout=2)
-        # # except Exception:
-        # except Exception as e:
-        #     print(f"Failed to send shutdown signal: {e}")
-        #     pass
-        try:
-            # Stop the Docker container
-            cp: subprocess.CompletedProcess
-            cp = subprocess.run(
-                ["docker", "stop", self.container_name],
-                capture_output=True,
-                text=True,
-                check=True,
-            )
-            if cp.returncode != 0:
-                print(f"Failed to stop Docker container: {cp.stderr}")
-
-            cp = subprocess.run(
-                ["docker", "rm", self.container_name],
-                capture_output=True,
-                text=True,
-                check=True,
-            )
-            if cp.returncode != 0:
-                print(f"Failed to remove Docker container: {cp.stderr}")
-
-            # Close the stdout pipe
-            if self.running_process and self.running_process.stdout:
-                self.running_process.stdout.close()
-
-                # Wait for the process to fully terminate with a timeout
-                self.running_process.wait(timeout=10)
-                if self.running_process.returncode is None:
-                    # kill
-                    self.running_process.kill()
-                if self.running_process.returncode is not None:
-                    print(
-                        f"Server stopped with return code {self.running_process.returncode}"
-                    )
-
-        except subprocess.TimeoutExpired:
-            # Force kill if it doesn't stop gracefully
-            if self.running_process:
-                self.running_process.kill()
-                self.running_process.wait()
-        except KeyboardInterrupt:
-            if self.running_process:
-                self.running_process.kill()
-                self.running_process.wait()
-        except Exception as e:
-            print(f"Error stopping Docker container: {e}")
-        finally:
-            self.running_process = None
-            self.running = False
+        # 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")

fastled/docker_manager.py

@@ -1,17 +1,36 @@
-"""Docker management functionality for FastLED WASM compiler."""
+"""
+New abstraction for Docker management with improved Ctrl+C handling.
+"""
 
+import _thread
 import subprocess
 import sys
+import threading
 import time
+import traceback
+import warnings
+from datetime import datetime, timezone
 from pathlib import Path
 
-import docker  # type: ignore
+import docker
+from appdirs import user_data_dir
+from disklru import DiskLRUCache
+from docker.client import DockerClient
+from docker.models.containers import Container
+from docker.models.images import Image
 from filelock import FileLock
 
-TAG = "main"
+CONFIG_DIR = Path(user_data_dir("fastled", "fastled"))
+CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+DB_FILE = CONFIG_DIR / "db.db"
+DISK_CACHE = DiskLRUCache(str(DB_FILE), 10)
 
-_HERE = Path(__file__).parent
-_FILE_LOCK = FileLock(str(_HERE / "fled.lock"))
+
+# Docker uses datetimes in UTC but without the timezone info. If we pass in a tz
+# then it will throw an exception.
+def _utc_now_no_tz() -> datetime:
+    now = datetime.now(timezone.utc)
+    return now.replace(tzinfo=None)
 
 
 def _win32_docker_location() -> str | None:
@@ -26,11 +45,54 @@ def _win32_docker_location() -> str | None:
     return None
 
 
+_HERE = Path(__file__).parent
+_FILE_LOCK = FileLock(str(_HERE / "fled.lock"))
+
+
+class RunningContainer:
+    def __init__(self, container, first_run=False):
+        self.container = container
+        self.first_run = first_run
+        self.running = True
+        self.thread = threading.Thread(target=self._log_monitor)
+        self.thread.daemon = True
+        self.thread.start()
+
+    def _log_monitor(self):
+        from_date = _utc_now_no_tz() if not self.first_run else None
+        to_date = _utc_now_no_tz()
+
+        while self.running:
+            try:
+                for log in self.container.logs(
+                    follow=False, since=from_date, until=to_date, stream=True
+                ):
+                    print(log.decode("utf-8"), end="")
+                time.sleep(0.1)
+                from_date = to_date
+                to_date = _utc_now_no_tz()
+            except KeyboardInterrupt:
+                print("Monitoring logs interrupted by user.")
+                _thread.interrupt_main()
+                break
+            except Exception as e:
+                print(f"Error monitoring logs: {e}")
+                break
+
+    def stop(self) -> None:
+        """Stop monitoring the container logs"""
+        self.running = False
+        self.thread.join()
+
+
 class DockerManager:
-    """Manages Docker operations for FastLED WASM compiler."""
+    def __init__(self) -> None:
+        self.client: DockerClient = docker.from_env()
+        self.first_run = False
 
-    def __init__(self, container_name: str):
-        self.container_name = container_name
+    def get_lock(self) -> FileLock:
+        """Get the file lock for this DockerManager instance."""
+        return _FILE_LOCK
 
     @staticmethod
     def is_docker_installed() -> bool:
@@ -46,9 +108,13 @@ class DockerManager:
             print("Docker is not installed.")
             return False
 
-    def is_running(self) -> bool:
+    @staticmethod
+    def is_running() -> bool:
         """Check if Docker is running by pinging the Docker daemon."""
+        if not DockerManager.is_docker_installed():
+            return False
         try:
+            # self.client.ping()
             client = docker.from_env()
             client.ping()
             print("Docker is running.")
@@ -104,158 +170,344 @@ class DockerManager:
             print(f"Error starting Docker: {str(e)}")
         return False
 
-    def ensure_linux_containers(self) -> bool:
-        """Ensure Docker is using Linux containers on Windows."""
-        if sys.platform == "win32":
-            try:
-                # Check if we're already in Linux container mode
-                result = subprocess.run(
-                    ["docker", "info"], capture_output=True, text=True, check=True
-                )
-                if "linux" in result.stdout.lower():
-                    return True
+    def validate_or_download_image(
+        self, image_name: str, tag: str = "latest", upgrade: bool = False
+    ) -> None:
+        """
+        Validate if the image exists, and if not, download it.
+        If upgrade is True, will pull the latest version even if image exists locally.
+        """
+        print(f"Validating image {image_name}:{tag}...")
 
-                print("Switching to Linux containers...")
-                subprocess.run(
-                    ["cmd", "/c", "docker context ls"], check=True, capture_output=True
-                )
-                subprocess.run(
-                    ["cmd", "/c", "docker context use default"],
-                    check=True,
-                    capture_output=True,
+        try:
+            local_image = self.client.images.get(f"{image_name}:{tag}")
+            print(f"Image {image_name}:{tag} is already available.")
+
+            if upgrade:
+                remote_image = self.client.images.get_registry_data(
+                    f"{image_name}:{tag}"
                 )
-                return True
-            except subprocess.CalledProcessError as e:
-                print(f"Failed to switch to Linux containers: {e}")
-                print(f"stdout: {e.stdout}")
-                print(f"stderr: {e.stderr}")
-                return False
-        return True  # Non-Windows platforms don't need this
+                remote_image_hash = remote_image.id
+                try:
+                    remote_image_hash_from_local_image = DISK_CACHE.get(local_image.id)
+                except KeyboardInterrupt:
+                    raise
+                except Exception:
+                    remote_image_hash_from_local_image = None
+                    import traceback
+                    import warnings
+
+                    stack = traceback.format_exc()
+                    warnings.warn(
+                        f"Error getting remote image hash from local image: {stack}"
+                    )
+                if remote_image_hash_from_local_image == remote_image_hash:
+                    print(f"Local image {image_name}:{tag} is up to date.")
+                    return
+
+                # Quick check for latest version
+
+                print(f"Pulling newer version of {image_name}:{tag}...")
+                _ = self.client.images.pull(image_name, tag=tag)
+                print(f"Updated to newer version of {image_name}:{tag}")
+                local_image_hash = self.client.images.get(f"{image_name}:{tag}").id
+                DISK_CACHE.put(local_image_hash, remote_image_hash)
+
+        except docker.errors.ImageNotFound:
+            print(f"Image {image_name}:{tag} not found. Downloading...")
+            self.client.images.pull(image_name, tag=tag)
+            try:
+                local_image = self.client.images.get(f"{image_name}:{tag}")
+                local_image_hash = local_image.id
+                DISK_CACHE.put(local_image_hash, remote_image_hash)
+                print(f"Image {image_name}:{tag} downloaded successfully.")
+            except docker.errors.ImageNotFound:
+                import warnings
 
-    def get_lock(self) -> FileLock:
-        """Get the file lock for this DockerManager instance."""
-        return _FILE_LOCK
+                warnings.warn(f"Image {image_name}:{tag} not found after download.")
 
-    def ensure_image_exists(self, force_update: bool = False) -> bool:
-        """Check if local image exists, pull from remote if not or if update requested."""
+    def tag_image(self, image_name: str, old_tag: str, new_tag: str) -> None:
+        """
+        Tag an image with a new tag.
+        """
+        image: Image = self.client.images.get(f"{image_name}:{old_tag}")
+        image.tag(image_name, new_tag)
+        print(f"Image {image_name}:{old_tag} tagged as {new_tag}.")
 
+    def _container_configs_match(
+        self,
+        container: Container,
+        command: str | None,
+        volumes: dict | None,
+        ports: dict | None,
+    ) -> bool:
+        """Compare if existing container has matching configuration"""
         try:
-            if not self.ensure_linux_containers():
-                return False
+            # Check if container is using the same image
+            container_image_id = container.image.id
+            container_image_tags = container.image.tags
 
-            image_name = f"{self.container_name}:{TAG}"
-            remote_image = f"niteris/fastled-wasm:{TAG}"
-            print("Pulling latest")
-            cmd_check_newer_image = [
-                "docker",
-                "pull",
-                remote_image,
-            ]
-            result = subprocess.run(
-                cmd_check_newer_image,
-                text=True,
-                check=False,
-            )
-            if result.returncode != 0:
-                print("Failed to check for newer image.")
-                return False
-            print("Tagging image")
-
-            tag_result = subprocess.run(
-                [
-                    "docker",
-                    "tag",
-                    remote_image,
-                    image_name,
-                ],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            if tag_result.returncode != 0:
-                print(f"Failed to tag image: {tag_result.stderr}")
+            # Simplified image comparison - just compare the IDs directly
+            if not container_image_tags:
+                print(f"Container using untagged image with ID: {container_image_id}")
+            else:
+                current_image = self.client.images.get(container_image_tags[0])
+                if container_image_id != current_image.id:
+                    print(
+                        f"Container using different image version. Container: {container_image_id}, Current: {current_image.id}"
+                    )
+                    return False
+
+            # Check command if specified
+            if command and container.attrs["Config"]["Cmd"] != command.split():
+                print(
+                    f"Command mismatch: {container.attrs['Config']['Cmd']} != {command}"
+                )
                 return False
-            return True
-        except subprocess.CalledProcessError as e:
-            print(f"Failed to ensure image exists: {e}")
-            return False
 
-    def container_exists(self) -> bool:
-        """Check if a container with the given name exists."""
-        try:
-            result = subprocess.run(
-                ["docker", "container", "inspect", self.container_name],
-                capture_output=True,
-                check=False,
-            )
-            return result.returncode == 0
-        except subprocess.CalledProcessError:
-            return False
+            # Check volumes if specified
+            if volumes:
+                container_mounts = (
+                    {
+                        m["Source"]: {"bind": m["Destination"], "mode": m["Mode"]}
+                        for m in container.attrs["Mounts"]
+                    }
+                    if container.attrs.get("Mounts")
+                    else {}
+                )
 
-    def remove_container(self) -> bool:
-        """Remove a container if it exists."""
-        try:
-            subprocess.run(
-                ["docker", "rm", "-f", self.container_name],
-                check=True,
-            )
-            return True
-        except subprocess.CalledProcessError:
-            return False
+                for host_dir, mount in volumes.items():
+                    if host_dir not in container_mounts:
+                        print(f"Volume {host_dir} not found in container mounts.")
+                        return False
+                    if container_mounts[host_dir] != mount:
+                        print(
+                            f"Volume {host_dir} has different mount options: {container_mounts[host_dir]} != {mount}"
+                        )
+                        return False
+
+            # Check ports if specified
+            if ports:
+                container_ports = (
+                    container.attrs["Config"]["ExposedPorts"]
+                    if container.attrs["Config"].get("ExposedPorts")
+                    else {}
+                )
+                container_port_bindings = (
+                    container.attrs["HostConfig"]["PortBindings"]
+                    if container.attrs["HostConfig"].get("PortBindings")
+                    else {}
+                )
 
-    def full_container_name(self) -> str:
-        """Get the name of the container."""
-        return f"{self.container_name}:{TAG}"
+                for container_port, host_port in ports.items():
+                    port_key = f"{container_port}/tcp"
+                    if port_key not in container_ports:
+                        print(f"Container port {port_key} not found.")
+                        return False
+                    if not container_port_bindings.get(port_key, [{"HostPort": None}])[
+                        0
+                    ]["HostPort"] == str(host_port):
+                        print(f"Port {host_port} is not bound to {port_key}.")
+                        return False
+        except KeyboardInterrupt:
+            raise
+        except docker.errors.NotFound:
+            print("Container not found.")
+            return False
+        except Exception as e:
+            stack = traceback.format_exc()
+            warnings.warn(f"Error checking container config: {e}\n{stack}")
+            return False
+        return True
 
     def run_container(
         self,
-        cmd: list[str],
+        image_name: str,
+        tag: str,
+        container_name: str,
+        command: str | None = None,
         volumes: dict[str, dict[str, str]] | None = None,
         ports: dict[int, int] | None = None,
-        tty: bool = False,
-    ) -> subprocess.Popen:
-        """Run the Docker container with the specified volume.
+    ) -> Container:
+        """
+        Run a container from an image. If it already exists with matching config, start it.
+        If it exists with different config, remove and recreate it.
 
         Args:
-            cmd: Command to run in the container
             volumes: Dict mapping host paths to dicts with 'bind' and 'mode' keys
+                    Example: {'/host/path': {'bind': '/container/path', 'mode': 'rw'}}
             ports: Dict mapping host ports to container ports
+                    Example: {8080: 80} maps host port 8080 to container port 80
         """
-        volumes = volumes or {}
-        ports = ports or {}
-
-        print("Creating new container...")
-        docker_command = ["docker", "run"]
-
-        if tty:
-            assert sys.stdout.isatty(), "TTY mode requires a TTY"
-            docker_command.append("-it")
-        # Attach volumes if specified
-        docker_command += [
-            "--name",
-            self.container_name,
-        ]
-        if ports:
-            for host_port, container_port in ports.items():
-                docker_command.extend(["-p", f"{host_port}:{container_port}"])
-        if volumes:
-            for host_path, mount_spec in volumes.items():
-                docker_command.extend(
-                    ["-v", f"{host_path}:{mount_spec['bind']}:{mount_spec['mode']}"]
+        image_name = f"{image_name}:{tag}"
+        try:
+            container: Container = self.client.containers.get(container_name)
+
+            # Check if configuration matches
+            if not self._container_configs_match(container, command, volumes, ports):
+                print(
+                    f"Container {container_name} exists but with different configuration. Removing and recreating..."
                 )
+                container.remove(force=True)
+                raise docker.errors.NotFound("Container removed due to config mismatch")
+            print(f"Container {container_name} found with matching configuration.")
+
+            # Existing container with matching config - handle various states
+            if container.status == "running":
+                print(f"Container {container_name} is already running.")
+            elif container.status == "exited":
+                print(f"Starting existing container {container_name}.")
+                container.start()
+            elif container.status == "restarting":
+                print(f"Waiting for container {container_name} to restart...")
+                timeout = 10
+                container.wait(timeout=10)
+                if container.status == "running":
+                    print(f"Container {container_name} has restarted.")
+                else:
+                    print(
+                        f"Container {container_name} did not restart within {timeout} seconds."
+                    )
+                    container.stop()
+                    print(f"Container {container_name} has been stopped.")
+                    container.start()
+            elif container.status == "paused":
+                print(f"Resuming existing container {container_name}.")
+                container.unpause()
+            else:
+                print(f"Unknown container status: {container.status}")
+                print(f"Starting existing container {container_name}.")
+                self.first_run = True
+                container.start()
+        except docker.errors.NotFound:
+            print(f"Creating and starting {container_name}")
+            container = self.client.containers.run(
+                image_name,
+                command,
+                name=container_name,
+                detach=True,
+                tty=True,
+                volumes=volumes,
+                ports=ports,
+            )
+        return container
 
-        docker_command.extend(
-            [
-                f"{self.container_name}:{TAG}",
-            ]
-        )
-        docker_command.extend(cmd)
+    def attach_and_run(self, container: Container | str) -> RunningContainer:
+        """
+        Attach to a running container and monitor its logs in a background thread.
+        Returns a RunningContainer object that can be used to stop monitoring.
+        """
+        if isinstance(container, str):
+            container = self.get_container(container)
+
+        print(f"Attaching to container {container.name}...")
+
+        first_run = self.first_run
+        self.first_run = False
+
+        return RunningContainer(container, first_run)
+
+    def suspend_container(self, container: Container | str) -> None:
+        """
+        Suspend (pause) the container.
+        """
+        if isinstance(container, str):
+            container_name = container
+            container = self.get_container(container)
+            if not container:
+                print(f"Could not put container {container_name} to sleep.")
+                return
+        try:
+            container.pause()
+            print(f"Container {container.name} has been suspended.")
+        except KeyboardInterrupt:
+            print(f"Container {container.name} interrupted by keyboard interrupt.")
+        except Exception as e:
+            print(f"Failed to suspend container {container.name}: {e}")
+
+    def resume_container(self, container: Container | str) -> None:
+        """
+        Resume (unpause) the container.
+        """
+        if isinstance(container, str):
+            container = self.get_container(container)
+        try:
+            container.unpause()
+            print(f"Container {container.name} has been resumed.")
+        except Exception as e:
+            print(f"Failed to resume container {container.name}: {e}")
+
+    def get_container(self, container_name: str) -> Container:
+        """
+        Get a container by name.
+        """
+        try:
+            return self.client.containers.get(container_name)
+        except docker.errors.NotFound:
+            print(f"Container {container_name} not found.")
+            raise
+
+    def is_container_running(self, container_name: str) -> bool:
+        """
+        Check if a container is running.
+        """
+        try:
+            container = self.client.containers.get(container_name)
+            return container.status == "running"
+        except docker.errors.NotFound:
+            print(f"Container {container_name} not found.")
+            return False
+
+
+def main():
+    # Register SIGINT handler
+    # signal.signal(signal.SIGINT, handle_sigint)
+
+    docker_manager = DockerManager()
 
-        print(f"Running command: {' '.join(docker_command)}")
+    # Parameters
+    image_name = "python"
+    tag = "3.10-slim"
+    # new_tag = "my-python"
+    container_name = "my-python-container"
+    command = "python -m http.server"
 
-        process = subprocess.Popen(
-            docker_command,
-            text=True,
+    try:
+        # Step 1: Validate or download the image
+        docker_manager.validate_or_download_image(image_name, tag, upgrade=True)
+
+        # Step 2: Tag the image
+        # docker_manager.tag_image(image_name, tag, new_tag)
+
+        # Step 3: Run the container
+        container = docker_manager.run_container(
+            image_name, tag, container_name, command
         )
 
-        return process
+        # Step 4: Attach and monitor the container logs
+        running_container = docker_manager.attach_and_run(container)
+
+        # Wait for keyboard interrupt
+        while True:
+            time.sleep(0.1)
+
+    except KeyboardInterrupt:
+        print("\nStopping container...")
+        running_container.stop()
+        container = docker_manager.get_container(container_name)
+        docker_manager.suspend_container(container)
+
+    try:
+        # Suspend and resume the container
+        container = docker_manager.get_container(container_name)
+        docker_manager.suspend_container(container)
+
+        input("Press Enter to resume the container...")
+
+        docker_manager.resume_container(container)
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+
+if __name__ == "__main__":
+    main()

fastled/web_compile.py

@@ -5,7 +5,7 @@ import os
 import shutil
 import tempfile
 import zipfile
-from concurrent.futures import Future, ProcessPoolExecutor, as_completed
+from concurrent.futures import Future, ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -21,7 +21,7 @@ ENDPOINT_COMPILED_WASM = "compile/wasm"
 _TIMEOUT = 60 * 4  # 2 mins timeout
 _AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
 ENABLE_EMBEDDED_DATA = True
-_EXECUTOR = ProcessPoolExecutor(max_workers=8)
+_EXECUTOR = ThreadPoolExecutor(max_workers=8)
 
 
 @dataclass
@@ -66,16 +66,11 @@ def _test_connection(host: str, use_ipv4: bool) -> ConnectionResult:
             )
             result = ConnectionResult(host, test_response.status_code == 200, use_ipv4)
     except KeyboardInterrupt:
-        # main thraed interrupt
-
         _thread.interrupt_main()
 
     except TimeoutError:
         result = ConnectionResult(host, False, use_ipv4)
-    except Exception as e:
-        import warnings
-
-        warnings.warn(f"Connection failed: {e}")
+    except Exception:
         result = ConnectionResult(host, False, use_ipv4)
     return result
 

{fastled-1.1.15.dist-info → fastled-1.1.16.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: fastled
-Version: 1.1.15
+Version: 1.1.16
 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,7 @@ A: A big chunk of space is being used by unnecessary javascript `emscripten` is
 
 # Revisions
 
+  * 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.dist-info → fastled-1.1.16.dist-info}/RECORD

@@ -1,20 +1,20 @@
-fastled/__init__.py,sha256=2BNTyVWziwf2g_946IKK7hNoB3ufZnDa9odeUM0JvlA,64
-fastled/app.py,sha256=7qjfLbqSlLVmkLifHaEkRAXo0ZRiJFiBCDvAxeOJX8Y,15290
+fastled/__init__.py,sha256=lSQZ1Dcii_FVM8VSJksjq9KpLmMsNl8jlUnsYp7Ko7I,64
+fastled/app.py,sha256=5ZKCN8XwcK6wfbp7hQRg-hUkZOSMJgmiTksQ8oX2rME,15094
 fastled/build_mode.py,sha256=joMwsV4K1y_LijT4gEAcjx69RZBoe_KmFmHZdPYbL_4,631
 fastled/cli.py,sha256=CNR_pQR0sNVPNuv8e_nmm-0PI8sU-eUBUgnWgWkzW9c,237
-fastled/compile_server.py,sha256=baXSd8V3C2tA--oYl8-_TPEvJxtNYck788W-iT-xyi8,8022
-fastled/docker_manager.py,sha256=gaDZpFV7E-9JhYIn6ahkP--9dGT32-WR5wZaU-o--6g,9107
+fastled/compile_server.py,sha256=IKdW82dswZSWrp8oCH4khAMYqz6Vf_65m1ad8m2aSHA,5304
+fastled/docker_manager.py,sha256=m09qpT5GnmofPGkPIV6KDJWYduRdRZhQAntBpJoV-24,19722
 fastled/filewatcher.py,sha256=fJNMQRDCpihSL4nQeYPqbD4m1Jzjcz_-YRAo-wlPW6k,6518
 fastled/keyboard.py,sha256=rqndglWYzRy6oiqHgsmx1peLd0Yrpci01zGENlCzh_s,2576
 fastled/open_browser.py,sha256=RRHcsZ5Vzsw1AuZUEYuSfjKmf_9j3NGMDUR-FndHmqs,1483
 fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
 fastled/sketch.py,sha256=KhhPFqlFVlBk8YrzFy7-ioe7zEzecgrVLhyFbLpBp7k,1845
 fastled/util.py,sha256=t4M3NFMhnCzfYbLvIyJi0RdFssZqbTN_vVIaej1WV-U,265
-fastled/web_compile.py,sha256=QXPtSQfWle4JVd3IG-ZHz-LfRsHiYWQRl2yRXH34m4s,10492
+fastled/web_compile.py,sha256=KuvKGdX6SSUUqC7YgX4T9SMSP5wdcPUhpg9-K9zPoTI,10378
 fastled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
-fastled-1.1.15.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-fastled-1.1.15.dist-info/METADATA,sha256=L7sRuUoYogtP4T95QHkLM23ds3SZTdp2V75R13vlzlE,13223
-fastled-1.1.15.dist-info/WHEEL,sha256=0VNUDWQJzfRahYI3neAhz2UVbRCtztpN5dPHAGvmGXc,109
-fastled-1.1.15.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
-fastled-1.1.15.dist-info/top_level.txt,sha256=xfG6Z_ol9V5YmBROkZq2QTRwjbS2ouCUxaTJsOwfkOo,14
-fastled-1.1.15.dist-info/RECORD,,
+fastled-1.1.16.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.1.16.dist-info/METADATA,sha256=a7SXnewYqDzmkJF6sUkgfn0IwYH_yByh3HbUfxnhDYg,13375
+fastled-1.1.16.dist-info/WHEEL,sha256=0VNUDWQJzfRahYI3neAhz2UVbRCtztpN5dPHAGvmGXc,109
+fastled-1.1.16.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.1.16.dist-info/top_level.txt,sha256=xfG6Z_ol9V5YmBROkZq2QTRwjbS2ouCUxaTJsOwfkOo,14
+fastled-1.1.16.dist-info/RECORD,,