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

fastled/docker_manager.py

@@ -3,6 +3,7 @@ New abstraction for Docker management with improved Ctrl+C handling.
 """
 
 import _thread
+import json
 import os
 import platform
 import subprocess
@@ -11,6 +12,7 @@ import threading
 import time
 import traceback
 import warnings
+from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -18,17 +20,22 @@ import docker
 from appdirs import user_data_dir
 from disklru import DiskLRUCache
 from docker.client import DockerClient
+from docker.errors import DockerException, ImageNotFound, NotFound
 from docker.models.containers import Container
 from docker.models.images import Image
 from filelock import FileLock
 
-from fastled.spinner import Spinner
+from fastled.print_filter import PrintFilter, PrintFilterDefault
 
 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)
 _IS_GITHUB = "GITHUB_ACTIONS" in os.environ
+_DEFAULT_BUILD_DIR = "/js/.pio/build"
+
+
+FORCE_CLEAR: bool = bool(os.environ.get("FASTLED_FORCE_CLEAR", "0") == "1")
 
 
 # Docker uses datetimes in UTC but without the timezone info. If we pass in a tz
@@ -38,6 +45,37 @@ def _utc_now_no_tz() -> datetime:
     return now.replace(tzinfo=None)
 
 
+def set_ramdisk_size(size: str) -> None:
+    """Set the tmpfs size for the container."""
+    # This is a hack to set the tmpfs size from the environment variable.
+    # It should be set in the docker-compose.yml file.
+    # If not set, return 25MB.
+    try:
+        os.environ["TMPFS_SIZE"] = str(size)
+    except ValueError:
+        os.environ["TMPFS_SIZE"] = "0"  # Defaults to off
+
+
+def get_ramdisk_size() -> str | None:
+    """Get the tmpfs size for the container."""
+    # This is a hack to get the tmpfs size from the environment variable.
+    # It should be set in the docker-compose.yml file.
+    # If not set, return 25MB.
+    try:
+        return os.environ.get("TMPFS_SIZE", None)
+    except ValueError:
+        return None  # Defaults to off
+
+
+def get_force_remove_image_previous() -> bool:
+    """Get the force remove image previous value."""
+    return os.environ.get("FASTLED_FORCE_CLEAR", "0") == "1"
+
+
+def set_clear() -> None:
+    os.environ["FASTLED_FORCE_CLEAR"] = "1"
+
+
 def _win32_docker_location() -> str | None:
     home_dir = Path.home()
     out = [
@@ -57,11 +95,59 @@ def get_lock(image_name: str) -> FileLock:
     print(CONFIG_DIR)
     if not lock_file.parent.exists():
         lock_file.parent.mkdir(parents=True, exist_ok=True)
-    return FileLock(str(lock_file))
+    out: FileLock
+    out = FileLock(str(lock_file))  # type: ignore
+    return out
+
+
+@dataclass
+class Volume:
+    """
+    Represents a Docker volume mapping between host and container.
+
+    Attributes:
+        host_path: Path on the host system (e.g., "C:\\Users\\username\\project")
+        container_path: Path inside the container (e.g., "/app/data")
+        mode: Access mode, "rw" for read-write or "ro" for read-only
+    """
+
+    host_path: str
+    container_path: str
+    mode: str = "rw"
+
+    def to_dict(self) -> dict[str, dict[str, str]]:
+        """Convert the Volume object to the format expected by Docker API."""
+        return {self.host_path: {"bind": self.container_path, "mode": self.mode}}
+
+    @classmethod
+    def from_dict(cls, volume_dict: dict[str, dict[str, str]]) -> list["Volume"]:
+        """Create Volume objects from a Docker volume dictionary."""
+        volumes = []
+        for host_path, config in volume_dict.items():
+            volumes.append(
+                cls(
+                    host_path=host_path,
+                    container_path=config["bind"],
+                    mode=config.get("mode", "rw"),
+                )
+            )
+        return volumes
+
+
+# Override the default PrintFilter to use a custom one.
+def make_default_print_filter() -> PrintFilter:
+    """Create a default PrintFilter instance."""
+    return PrintFilterDefault()
 
 
 class RunningContainer:
-    def __init__(self, container, first_run=False):
+    def __init__(
+        self,
+        container: Container,
+        first_run: bool = False,
+        filter: PrintFilter | None = None,
+    ) -> None:
+        self.filter = filter or make_default_print_filter()
         self.container = container
         self.first_run = first_run
         self.running = True
@@ -78,7 +164,8 @@ class RunningContainer:
                 for log in self.container.logs(
                     follow=False, since=from_date, until=to_date, stream=True
                 ):
-                    print(log.decode("utf-8"), end="")
+                    # print(log.decode("utf-8"), end="")
+                    self.filter.print(log)
                 time.sleep(0.1)
                 from_date = to_date
                 to_date = _utc_now_no_tz()
@@ -95,11 +182,64 @@ class RunningContainer:
         self.running = False
         self.thread.join()
 
+    def stop(self) -> None:
+        """Stop the container"""
+        self.container.stop()
+        self.detach()
+
+
+def _hack_to_fix_mac(volumes: list[Volume] | None) -> list[Volume] | None:
+    """Fixes the volume mounts on MacOS by removing the mode."""
+    if volumes is None:
+        return None
+    if sys.platform != "darwin":
+        # Only macos needs hacking.
+        return volumes
+
+    volumes = volumes.copy()
+    # Work around a Docker bug on MacOS where the expected network socket to the
+    # the host is not mounted correctly. This was actually fixed in recent versions
+    # of docker client but there is a large chunk of Docker clients out there with
+    # this bug in it.
+    #
+    # This hack is done by mounting the socket directly to the container.
+    # This socket talks to the docker daemon on the host.
+    #
+    # Found here.
+    # https://github.com/docker/docker-py/issues/3069#issuecomment-1316778735
+    # if it exists already then return the input
+    for volume in volumes:
+        if volume.host_path == "/var/run/docker.sock":
+            return volumes
+    # ok it doesn't exist, so add it
+    volumes.append(
+        Volume(
+            host_path="/var/run/docker.sock",
+            container_path="/var/run/docker.sock",
+            mode="rw",
+        )
+    )
+    return volumes
+
+
+def set_force_remove_image_previous(new_value: str | None = None) -> None:
+    if new_value is not None:
+        os.environ["FASTLED_FORCE_CLEAR"] = new_value
+    else:
+        os.environ["FASTLED_FORCE_CLEAR"] = "1"
+
+
+def force_image_removal() -> bool:
+    """Get the force remove image previous value."""
+    return os.environ.get("FASTLED_FORCE_CLEAR", "0") == "1"
+
 
 class DockerManager:
     def __init__(self) -> None:
         from docker.errors import DockerException
 
+        self.is_suspended: bool = False
+
         try:
             self._client: DockerClient | None = None
             self.first_run = False
@@ -111,7 +251,34 @@ class DockerManager:
     @property
     def client(self) -> DockerClient:
         if self._client is None:
-            self._client = docker.from_env()
+            # Retry logic for WSL startup on Windows
+            max_retries = 10
+            retry_delay = 2  # seconds
+            last_error = None
+
+            for attempt in range(max_retries):
+                try:
+                    self._client = docker.from_env()
+                    if attempt > 0:
+                        print(
+                            f"Successfully connected to Docker after {attempt + 1} attempts"
+                        )
+                    return self._client
+                except DockerException as e:
+                    last_error = e
+                    if attempt < max_retries - 1:
+                        if attempt == 0:
+                            print("Waiting for Docker/WSL to be ready...")
+                        print(
+                            f"Attempt {attempt + 1}/{max_retries} failed, retrying in {retry_delay}s..."
+                        )
+                        time.sleep(retry_delay)
+                    else:
+                        print(
+                            f"Failed to connect to Docker after {max_retries} attempts"
+                        )
+                        raise last_error
+        assert self._client is not None
         return self._client
 
     @staticmethod
@@ -181,10 +348,6 @@ class DockerManager:
             )
             return False
 
-        except subprocess.CalledProcessError as e:
-            print(f"Error occurred: {e}")
-            return False
-
         except subprocess.CalledProcessError as e:
             print(f"Failed to switch to Linux containers: {e}")
             if e.stdout:
@@ -197,22 +360,24 @@ class DockerManager:
             return False
 
     @staticmethod
-    def is_running() -> bool:
+    def is_running() -> tuple[bool, Exception | None]:
         """Check if Docker is running by pinging the Docker daemon."""
+
         if not DockerManager.is_docker_installed():
-            return False
+            print("Docker is not installed.")
+            return False, Exception("Docker is not installed.")
         try:
             # self.client.ping()
             client = docker.from_env()
             client.ping()
             print("Docker is running.")
-            return True
-        except docker.errors.DockerException as e:
+            return True, None
+        except DockerException as e:
             print(f"Docker is not running: {str(e)}")
-            return False
+            return False, e
         except Exception as e:
             print(f"Error pinging Docker daemon: {str(e)}")
-            return False
+            return False, e
 
     def start(self) -> bool:
         """Attempt to start Docker Desktop (or the Docker daemon) automatically."""
@@ -226,7 +391,8 @@ class DockerManager:
                     return False
                 subprocess.run(["start", "", docker_path], shell=True)
             elif sys.platform == "darwin":
-                subprocess.run(["open", "/Applications/Docker.app"])
+                subprocess.run(["open", "-a", "Docker"])
+                time.sleep(2)  # Give Docker time to start
             elif sys.platform.startswith("linux"):
                 subprocess.run(["sudo", "systemctl", "start", "docker"])
             else:
@@ -261,9 +427,69 @@ class DockerManager:
             print(f"Error starting Docker: {str(e)}")
         return False
 
+    def has_newer_version(
+        self, image_name: str, tag: str = "latest"
+    ) -> tuple[bool, str]:
+        """
+        Check if a newer version of the image is available in the registry.
+
+        Args:
+            image_name: The name of the image to check
+            tag: The tag of the image to check
+
+        Returns:
+            A tuple of (has_newer_version, message)
+            has_newer_version: True if a newer version is available, False otherwise
+            message: A message describing the result, including the date of the newer version if available
+        """
+        try:
+            # Get the local image
+            local_image = self.client.images.get(f"{image_name}:{tag}")
+            local_image_id = local_image.id
+            assert local_image_id is not None
+
+            # Get the remote image data
+            remote_image = self.client.images.get_registry_data(f"{image_name}:{tag}")
+            remote_image_hash = remote_image.id
+
+            # Check if we have a cached remote hash for this local image
+            try:
+                remote_image_hash_from_local_image = DISK_CACHE.get(local_image_id)
+            except Exception:
+                remote_image_hash_from_local_image = None
+
+            # Compare the hashes
+            if remote_image_hash_from_local_image == remote_image_hash:
+                return False, f"Local image {image_name}:{tag} is up to date."
+            else:
+                # Get the creation date of the remote image if possible
+                try:
+                    # Try to get detailed image info including creation date
+                    remote_image_details = self.client.api.inspect_image(
+                        f"{image_name}:{tag}"
+                    )
+                    if "Created" in remote_image_details:
+                        created_date = remote_image_details["Created"].split("T")[
+                            0
+                        ]  # Extract just the date part
+                        return (
+                            True,
+                            f"Newer version of {image_name}:{tag} is available (published on {created_date}).",
+                        )
+                except Exception:
+                    pass
+
+                # Fallback if we couldn't get the date
+                return True, f"Newer version of {image_name}:{tag} is available."
+
+        except ImageNotFound:
+            return True, f"Image {image_name}:{tag} not found locally."
+        except DockerException as e:
+            return False, f"Error checking for newer version: {e}"
+
     def validate_or_download_image(
         self, image_name: str, tag: str = "latest", upgrade: bool = False
-    ) -> None:
+    ) -> bool:
         """
         Validate if the image exists, and if not, download it.
         If upgrade is True, will pull the latest version even if image exists locally.
@@ -289,8 +515,10 @@ class DockerManager:
                     remote_image_hash = remote_image.id
 
                     try:
+                        local_image_id = local_image.id
+                        assert local_image_id is not None
                         remote_image_hash_from_local_image = DISK_CACHE.get(
-                            local_image.id
+                            local_image_id
                         )
                     except KeyboardInterrupt:
                         raise
@@ -302,34 +530,32 @@ class DockerManager:
                         )
                     if remote_image_hash_from_local_image == remote_image_hash:
                         print(f"Local image {image_name}:{tag} is up to date.")
-                        return
+                        return False
 
                     # Quick check for latest version
-                    with Spinner(f"Pulling newer version of {image_name}:{tag}..."):
-                        # This needs to be swapped out using the the command line interface AI!
-                        # _ = self.client.images.pull(image_name, tag=tag)
-                        cmd_list = ["docker", "pull", f"{image_name}:{tag}"]
-                        cmd_str = subprocess.list2cmdline(cmd_list)
-                        print(f"Running command: {cmd_str}")
-                        subprocess.run(cmd_list, check=True)
+                    print(f"Pulling newer version of {image_name}:{tag}...")
+                    cmd_list = ["docker", "pull", f"{image_name}:{tag}"]
+                    subprocess.run(cmd_list, check=True)
                     print(f"Updated to newer version of {image_name}:{tag}")
                     local_image_hash = self.client.images.get(f"{image_name}:{tag}").id
+                    assert local_image_hash is not None
                     if remote_image_hash is not None:
                         DISK_CACHE.put(local_image_hash, remote_image_hash)
+                    return True
 
-            except docker.errors.ImageNotFound:
+            except ImageNotFound:
                 print(f"Image {image_name}:{tag} not found.")
-                with Spinner("Loading "):
-                    cmd_list = ["docker", "pull", f"{image_name}:{tag}"]
-                    cmd_str = subprocess.list2cmdline(cmd_list)
-                    print(f"Running command: {cmd_str}")
-                    subprocess.run(cmd_list, check=True)
+                print("Loading...")
+                # We use docker cli here because it shows the download.
+                cmd_list = ["docker", "pull", f"{image_name}:{tag}"]
+                subprocess.run(cmd_list, check=True)
                 try:
                     local_image = self.client.images.get(f"{image_name}:{tag}")
                     local_image_hash = local_image.id
                     print(f"Image {image_name}:{tag} downloaded successfully.")
-                except docker.errors.ImageNotFound:
+                except ImageNotFound:
                     warnings.warn(f"Image {image_name}:{tag} not found after download.")
+        return True
 
     def tag_image(self, image_name: str, old_tag: str, new_tag: str) -> None:
         """
@@ -343,14 +569,17 @@ class DockerManager:
         self,
         container: Container,
         command: str | None,
-        volumes: dict | None,
-        ports: dict | None,
+        volumes_dict: dict[str, dict[str, str]] | None,
+        ports: dict[int, int] | None,
     ) -> bool:
         """Compare if existing container has matching configuration"""
         try:
             # Check if container is using the same image
-            container_image_id = container.image.id
-            container_image_tags = container.image.tags
+            image = container.image
+            assert image is not None
+            container_image_id = image.id
+            container_image_tags = image.tags
+            assert container_image_id is not None
 
             # Simplified image comparison - just compare the IDs directly
             if not container_image_tags:
@@ -371,7 +600,7 @@ class DockerManager:
                 return False
 
             # Check volumes if specified
-            if volumes:
+            if volumes_dict:
                 container_mounts = (
                     {
                         m["Source"]: {"bind": m["Destination"], "mode": m["Mode"]}
@@ -381,7 +610,7 @@ class DockerManager:
                     else {}
                 )
 
-                for host_dir, mount in volumes.items():
+                for host_dir, mount in volumes_dict.items():
                     if host_dir not in container_mounts:
                         print(f"Volume {host_dir} not found in container mounts.")
                         return False
@@ -416,7 +645,7 @@ class DockerManager:
                         return False
         except KeyboardInterrupt:
             raise
-        except docker.errors.NotFound:
+        except NotFound:
             print("Container not found.")
             return False
         except Exception as e:
@@ -431,20 +660,43 @@ class DockerManager:
         tag: str,
         container_name: str,
         command: str | None = None,
-        volumes: dict[str, dict[str, str]] | None = None,
+        volumes: list[Volume] | None = None,
         ports: dict[int, int] | None = None,
         remove_previous: bool = False,
+        environment: dict[str, str] | None = None,
+        tmpfs_size: str | None = None,  # suffixed like 25mb.
     ) -> 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:
-            volumes: Dict mapping host paths to dicts with 'bind' and 'mode' keys
-                    Example: {'/host/path': {'bind': '/container/path', 'mode': 'rw'}}
+            volumes: List of Volume objects for container volume mappings
             ports: Dict mapping host ports to container ports
                     Example: {8080: 80} maps host port 8080 to container port 80
         """
+        remove_previous = remove_previous or get_force_remove_image_previous()
+        if get_force_remove_image_previous():
+            # make a banner print
+            print(
+                "Force removing previous image due to FASTLED_FORCE_CLEAR environment variable."
+            )
+
+        tmpfs_size = tmpfs_size or get_ramdisk_size()
+        sys_admin = tmpfs_size is not None and tmpfs_size != "0"
+        volumes = _hack_to_fix_mac(volumes)
+        # Convert volumes to the format expected by Docker API
+        volumes_dict = None
+        if volumes is not None:
+            volumes_dict = {}
+            for volume in volumes:
+                volumes_dict.update(volume.to_dict())
+
+        # Serialize the volumes to a json string
+        if volumes_dict:
+            volumes_str = json.dumps(volumes_dict)
+            print(f"Volumes: {volumes_str}")
+            print("Done")
         image_name = f"{image_name}:{tag}"
         try:
             container: Container = self.client.containers.get(container_name)
@@ -452,14 +704,16 @@ class DockerManager:
             if remove_previous:
                 print(f"Removing existing container {container_name}...")
                 container.remove(force=True)
-                raise docker.errors.NotFound("Container removed due to remove_previous")
+                raise NotFound("Container removed due to remove_previous")
             # Check if configuration matches
-            elif not self._container_configs_match(container, command, volumes, ports):
+            elif not self._container_configs_match(
+                container, command, volumes_dict, 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")
+                raise NotFound("Container removed due to config mismatch")
             print(f"Container {container_name} found with matching configuration.")
 
             # Existing container with matching config - handle various states
@@ -489,21 +743,28 @@ class DockerManager:
                 print(f"Starting existing container {container_name}.")
                 self.first_run = True
                 container.start()
-        except docker.errors.NotFound:
+        except NotFound:
             print(f"Creating and starting {container_name}")
             out_msg = f"# Running in container: {command}"
             msg_len = len(out_msg)
             print("\n" + "#" * msg_len)
             print(out_msg)
             print("#" * msg_len + "\n")
+
+            tmpfs: dict[str, str] | None = None
+            if tmpfs_size:
+                tmpfs = {_DEFAULT_BUILD_DIR: f"size={tmpfs_size}"}
             container = self.client.containers.run(
-                image_name,
-                command,
+                image=image_name,
+                command=command,
                 name=container_name,
+                tmpfs=tmpfs,
+                cap_add=["SYS_ADMIN"] if sys_admin else None,
                 detach=True,
                 tty=True,
-                volumes=volumes,
-                ports=ports,
+                volumes=volumes_dict,
+                ports=ports,  # type: ignore
+                environment=environment,
                 remove=True,
             )
         return container
@@ -514,14 +775,22 @@ class DockerManager:
         tag: str,
         container_name: str,
         command: str | None = None,
-        volumes: dict[str, dict[str, str]] | None = None,
+        volumes: list[Volume] | None = None,
         ports: dict[int, int] | None = None,
+        environment: dict[str, str] | None = None,
     ) -> None:
+        # Convert volumes to the format expected by Docker API
+        volumes = _hack_to_fix_mac(volumes)
+        volumes_dict = None
+        if volumes is not None:
+            volumes_dict = {}
+            for volume in volumes:
+                volumes_dict.update(volume.to_dict())
         # Remove existing container
         try:
             container: Container = self.client.containers.get(container_name)
             container.remove(force=True)
-        except docker.errors.NotFound:
+        except NotFound:
             pass
         start_time = time.time()
         try:
@@ -533,12 +802,19 @@ class DockerManager:
                 "--name",
                 container_name,
             ]
-            if volumes:
-                for host_dir, mount in volumes.items():
-                    docker_command.extend(["-v", f"{host_dir}:{mount['bind']}"])
+            if volumes_dict:
+                for host_dir, mount in volumes_dict.items():
+                    docker_volume_arg = [
+                        "-v",
+                        f"{host_dir}:{mount['bind']}:{mount['mode']}",
+                    ]
+                    docker_command.extend(docker_volume_arg)
             if ports:
                 for host_port, container_port in ports.items():
                     docker_command.extend(["-p", f"{host_port}:{container_port}"])
+            if environment:
+                for env_name, env_value in environment.items():
+                    docker_command.extend(["-e", f"{env_name}={env_value}"])
             docker_command.append(f"{image_name}:{tag}")
             if command:
                 docker_command.append(command)
@@ -558,7 +834,10 @@ class DockerManager:
         Returns a RunningContainer object that can be used to stop monitoring.
         """
         if isinstance(container, str):
-            container = self.get_container(container)
+            container_name = container
+            tmp = self.get_container(container)
+            assert tmp is not None, f"Container {container_name} not found."
+            container = tmp
 
         assert container is not None, "Container not found."
 
@@ -573,12 +852,17 @@ class DockerManager:
         """
         Suspend (pause) the container.
         """
+        if self.is_suspended:
+            return
         if isinstance(container, str):
             container_name = container
-            container = self.get_container(container)
-            if not container:
+            # container = self.get_container(container)
+            tmp = self.get_container(container_name)
+            if not tmp:
                 print(f"Could not put container {container_name} to sleep.")
                 return
+            container = tmp
+        assert isinstance(container, Container)
         try:
             if platform.system() == "Windows":
                 container.pause()
@@ -595,16 +879,27 @@ class DockerManager:
         """
         Resume (unpause) the container.
         """
+        container_name = "UNKNOWN"
         if isinstance(container, str):
-            container = self.get_container(container)
+            container_name = container
+            container_or_none = self.get_container(container)
+            if container_or_none is None:
+                print(f"Could not resume container {container}.")
+                return
+            container = container_or_none
+            container_name = container.name
+        elif isinstance(container, Container):
+            container_name = container.name
+        assert isinstance(container, Container)
         if not container:
             print(f"Could not resume container {container}.")
             return
         try:
+            assert isinstance(container, Container)
             container.unpause()
             print(f"Container {container.name} has been resumed.")
         except Exception as e:
-            print(f"Failed to resume container {container.name}: {e}")
+            print(f"Failed to resume container {container_name}: {e}")
 
     def get_container(self, container_name: str) -> Container | None:
         """
@@ -612,7 +907,7 @@ class DockerManager:
         """
         try:
             return self.client.containers.get(container_name)
-        except docker.errors.NotFound:
+        except NotFound:
             return None
 
     def is_container_running(self, container_name: str) -> bool:
@@ -622,7 +917,7 @@ class DockerManager:
         try:
             container = self.client.containers.get(container_name)
             return container.status == "running"
-        except docker.errors.NotFound:
+        except NotFound:
             print(f"Container {container_name} not found.")
             return False
 
@@ -694,7 +989,9 @@ class DockerManager:
                     print("Error decoding line")
             rtn = proc.wait()
             if rtn != 0:
-                print(f"Error building Docker image: {rtn}")
+                warnings.warn(
+                    f"Error building Docker image, is docker running? {rtn}, stdout: {stdout}, stderr: {proc.stderr}"
+                )
                 raise subprocess.CalledProcessError(rtn, cmd_str)
             print(f"Successfully built image {image_name}:{tag}")
 
@@ -705,6 +1002,7 @@ class DockerManager:
     def purge(self, image_name: str) -> None:
         """
         Remove all containers and images associated with the given image name.
+        Also removes FastLED containers by name pattern (including test containers).
 
         Args:
             image_name: The name of the image to purge (without tag)
@@ -715,8 +1013,27 @@ class DockerManager:
         try:
             containers = self.client.containers.list(all=True)
             for container in containers:
+                should_remove = False
+
+                # Check if container uses the specified image
                 if any(image_name in tag for tag in container.image.tags):
-                    print(f"Removing container {container.name}")
+                    should_remove = True
+                    print(
+                        f"Removing container {container.name} (uses image {image_name})"
+                    )
+
+                # Also check for FastLED container name patterns (including test containers)
+                elif any(
+                    pattern in container.name
+                    for pattern in [
+                        "fastled-wasm-container",
+                        "fastled-wasm-container-test",
+                    ]
+                ):
+                    should_remove = True
+                    print(f"Removing FastLED container {container.name}")
+
+                if should_remove:
                     container.remove(force=True)
 
         except Exception as e:
@@ -734,7 +1051,7 @@ class DockerManager:
             print(f"Error removing images: {e}")
 
 
-def main():
+def main() -> None:
     # Register SIGINT handler
     # signal.signal(signal.SIGINT, handle_sigint)
 
@@ -746,6 +1063,7 @@ def main():
     # new_tag = "my-python"
     container_name = "my-python-container"
     command = "python -m http.server"
+    running_container: RunningContainer | None = None
 
     try:
         # Step 1: Validate or download the image
@@ -768,13 +1086,18 @@ def main():
 
     except KeyboardInterrupt:
         print("\nStopping container...")
-        running_container.stop()
-        container = docker_manager.get_container(container_name)
-        docker_manager.suspend_container(container)
+        if isinstance(running_container, RunningContainer):
+            running_container.stop()
+        container_or_none = docker_manager.get_container(container_name)
+        if container_or_none is not None:
+            docker_manager.suspend_container(container_or_none)
+        else:
+            warnings.warn(f"Container {container_name} not found.")
 
     try:
         # Suspend and resume the container
         container = docker_manager.get_container(container_name)
+        assert container is not None, "Container not found."
         docker_manager.suspend_container(container)
 
         input("Press Enter to resume the container...")