fastled 1.2.5__tar.gz → 1.2.7__tar.gz

{fastled-1.2.5 → fastled-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastled
-Version: 1.2.5
+Version: 1.2.7
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -186,6 +186,14 @@ with Api.server() as server:
     client.stop()
 ```
 
+**Build Docker Image from a local copy of the FastLED repo**
+```python
+from fastapi import Docker, Api
+container_name: str = Docker.build_from_fastled_repo()
+with Api.server(container_name=container_name) as server:
+  ...
+```
+
 # Features
 
 ## Hot reload by default
@@ -266,6 +274,8 @@ A: A big chunk of space is being used by unnecessary javascript `emscripten` bun
 
 # Revisions
 
+  * 1.2.7 - A bunch of fixes for MacOS and probably linux.
+  * 1.2.6 - Now builds image from the project root of FastLED.
   * 1.1.25 - Fix up paths for `--init`
   * 1.1.24 - Mac/Linux now properly responds to ctrl-c when waiting for a key event.
   * 1.1.23 - Fixes missing `live-server` on platforms that don't have it already.

{fastled-1.2.5 → fastled-1.2.7}/README.md

@@ -163,6 +163,14 @@ with Api.server() as server:
     client.stop()
 ```
 
+**Build Docker Image from a local copy of the FastLED repo**
+```python
+from fastapi import Docker, Api
+container_name: str = Docker.build_from_fastled_repo()
+with Api.server(container_name=container_name) as server:
+  ...
+```
+
 # Features
 
 ## Hot reload by default
@@ -243,6 +251,8 @@ A: A big chunk of space is being used by unnecessary javascript `emscripten` bun
 
 # Revisions
 
+  * 1.2.7 - A bunch of fixes for MacOS and probably linux.
+  * 1.2.6 - Now builds image from the project root of FastLED.
   * 1.1.25 - Fix up paths for `--init`
   * 1.1.24 - Mac/Linux now properly responds to ctrl-c when waiting for a key event.
   * 1.1.23 - Fixes missing `live-server` on platforms that don't have it already.

fastled-1.2.7/src/fastled/__init__.py

@@ -0,0 +1,325 @@
+"""FastLED Wasm Compiler package."""
+
+# context
+import subprocess
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Generator
+
+from .compile_server import CompileServer
+from .live_client import LiveClient
+from .site.build import build
+from .types import BuildMode, CompileResult, CompileServerError
+
+# IMPORTANT! There's a bug in github which will REJECT any version update
+# that has any other change in the repo. Please bump the version as the
+# ONLY change in a commit, or else the pypi update and the release will fail.
+__version__ = "1.2.7"
+
+
+class Api:
+    @staticmethod
+    def get_examples(host: str | CompileServer | None = None) -> list[str]:
+        from fastled.project_init import get_examples
+
+        if isinstance(host, CompileServer):
+            host = host.url()
+
+        return get_examples(host=host)
+
+    @staticmethod
+    def project_init(
+        example=None, outputdir=None, host: str | CompileServer | None = None
+    ) -> Path:
+        from fastled.project_init import project_init
+
+        if isinstance(host, CompileServer):
+            host = host.url()
+        return project_init(example, outputdir, host)
+
+    @staticmethod
+    def web_compile(
+        directory: Path | str,
+        host: str | CompileServer | None = None,
+        build_mode: BuildMode = BuildMode.QUICK,
+        profile: bool = False,  # When true then profile information will be enabled and included in the zip.
+    ) -> CompileResult:
+        from fastled.web_compile import web_compile
+
+        if isinstance(host, CompileServer):
+            host = host.url()
+        if isinstance(directory, str):
+            directory = Path(directory)
+        out: CompileResult = web_compile(
+            directory, host, build_mode=build_mode, profile=profile
+        )
+        return out
+
+    @staticmethod
+    def live_client(
+        sketch_directory: Path,
+        host: str | CompileServer | None = None,
+        auto_start=True,
+        open_web_browser=True,
+        keep_running=True,
+        build_mode=BuildMode.QUICK,
+        profile=False,
+    ) -> LiveClient:
+        return LiveClient(
+            sketch_directory=sketch_directory,
+            host=host,
+            auto_start=auto_start,
+            open_web_browser=open_web_browser,
+            keep_running=keep_running,
+            build_mode=build_mode,
+            profile=profile,
+        )
+
+    @staticmethod
+    def spawn_server(
+        interactive=False,
+        auto_updates=None,
+        auto_start=True,
+        container_name: str | None = None,
+    ) -> CompileServer:
+        from fastled.compile_server import CompileServer
+
+        out = CompileServer(
+            container_name=container_name,
+            interactive=interactive,
+            auto_updates=auto_updates,
+            mapped_dir=None,
+            auto_start=auto_start,
+        )
+        return out
+
+    @staticmethod
+    @contextmanager
+    def server(
+        interactive=False,
+        auto_updates=None,
+        auto_start=True,
+        container_name: str | None = None,
+    ) -> Generator[CompileServer, None, None]:
+        server = Api.spawn_server(
+            interactive=interactive,
+            auto_updates=auto_updates,
+            auto_start=auto_start,
+            container_name=container_name,
+        )
+        try:
+            yield server
+        finally:
+            server.stop()
+
+
+class Docker:
+    @staticmethod
+    def is_installed() -> bool:
+        from fastled.docker_manager import DockerManager
+
+        return DockerManager.is_docker_installed()
+
+    @staticmethod
+    def is_running() -> bool:
+        from fastled.docker_manager import DockerManager
+
+        return DockerManager.is_running()
+
+    @staticmethod
+    def is_container_running(container_name: str | None = None) -> bool:
+        # from fastled.docker import is_container_running
+        from fastled.docker_manager import DockerManager
+        from fastled.settings import CONTAINER_NAME
+
+        docker_mgr = DockerManager()
+        container_name = container_name or CONTAINER_NAME
+        return docker_mgr.is_container_running(container_name)
+
+    @staticmethod
+    def purge() -> None:
+        from fastled.docker_manager import DockerManager
+        from fastled.settings import IMAGE_NAME
+
+        docker_mgr = DockerManager()
+        docker_mgr.purge(image_name=IMAGE_NAME)
+
+    @staticmethod
+    def build_from_github(
+        url: str = "https://github.com/fastled/fastled",
+        output_dir: Path | str = Path(".cache/fastled"),
+    ) -> str:
+        """Build the FastLED WASM compiler Docker image from a GitHub repository.
+
+        Args:
+            url: GitHub repository URL (default: https://github.com/fastled/fastled)
+            output_dir: Directory to clone the repo into (default: .cache/fastled)
+
+        Returns:
+            Container name.
+        """
+
+        from fastled.docker_manager import DockerManager
+        from fastled.settings import CONTAINER_NAME, IMAGE_NAME
+
+        if isinstance(output_dir, str):
+            output_dir = Path(output_dir)
+
+        # Create output directory if it doesn't exist
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Clone or update the repository
+        if (output_dir / ".git").exists():
+            print(f"Updating existing repository in {output_dir}")
+            # Reset local changes and move HEAD back to handle force pushes
+            subprocess.run(
+                ["git", "reset", "--hard", "HEAD~10"],
+                cwd=output_dir,
+                check=True,
+                capture_output=True,  # Suppress output of reset
+            )
+            subprocess.run(
+                ["git", "pull", "origin", "master"], cwd=output_dir, check=True
+            )
+        else:
+            print(f"Cloning {url} into {output_dir}")
+            subprocess.run(["git", "clone", url, str(output_dir)], check=True)
+
+        dockerfile_path = (
+            output_dir / "src" / "platforms" / "wasm" / "compiler" / "Dockerfile"
+        )
+
+        if not dockerfile_path.exists():
+            raise FileNotFoundError(
+                f"Dockerfile not found at {dockerfile_path}. "
+                "This may not be a valid FastLED repository."
+            )
+
+        docker_mgr = DockerManager()
+
+        platform_tag = ""
+        # if "arm" in docker_mgr.architecture():
+        if (
+            "arm"
+            in subprocess.run(["uname", "-m"], capture_output=True).stdout.decode()
+        ):
+            platform_tag = "-arm64"
+
+        # Build the image
+        docker_mgr.build_image(
+            image_name=IMAGE_NAME,
+            tag="main",
+            dockerfile_path=dockerfile_path,
+            build_context=output_dir,
+            build_args={"NO_PREWARM": "1"},
+            platform_tag=platform_tag,
+        )
+
+        # Run the container and return it
+        container = docker_mgr.run_container_detached(
+            image_name=IMAGE_NAME,
+            tag="main",
+            container_name=CONTAINER_NAME,
+            command=None,  # Use default command from Dockerfile
+            volumes=None,  # No volumes needed for build
+            ports=None,  # No ports needed for build
+            remove_previous=True,  # Remove any existing container
+        )
+
+        return container.name
+
+    @staticmethod
+    def build_from_fastled_repo(
+        project_root: Path | str = Path("."), platform_tag: str = ""
+    ) -> str:
+        """Build the FastLED WASM compiler Docker image, which will be tagged as "main".
+
+        Args:
+            project_root: Path to the FastLED project root directory
+            platform_tag: Optional platform tag (e.g. "-arm64" for ARM builds)
+
+        Returns:
+            The string name of the docker container.
+        """
+        from fastled.docker_manager import DockerManager
+        from fastled.settings import CONTAINER_NAME, IMAGE_NAME
+
+        if isinstance(project_root, str):
+            project_root = Path(project_root)
+
+        dockerfile_path = (
+            project_root / "src" / "platforms" / "wasm" / "compiler" / "Dockerfile"
+        )
+
+        docker_mgr = DockerManager()
+
+        platform_tag = ""
+        # if "arm" in docker_mgr.architecture():
+        if (
+            "arm"
+            in subprocess.run(["uname", "-m"], capture_output=True).stdout.decode()
+        ):
+            platform_tag = "-arm64"
+
+        # if image exists, remove it
+        docker_mgr.purge(image_name=IMAGE_NAME)
+
+        # Build the image
+        docker_mgr.build_image(
+            image_name=IMAGE_NAME,
+            tag="main",
+            dockerfile_path=dockerfile_path,
+            build_context=project_root,
+            build_args={"NO_PREWARM": "1"},
+            platform_tag=platform_tag,
+        )
+
+        # Run the container and return it
+        container = docker_mgr.run_container_detached(
+            image_name=IMAGE_NAME,
+            tag="main",
+            container_name=CONTAINER_NAME,
+            command=None,  # Use default command from Dockerfile
+            volumes=None,  # No volumes needed for build
+            ports=None,  # No ports needed for build
+            remove_previous=True,  # Remove any existing container
+        )
+        container_name = f"{container.name}"
+        return container_name
+
+
+class Test:
+    __test__ = False  # This prevents unittest from recognizing it as a test class.
+
+    @staticmethod
+    def can_run_local_docker_tests() -> bool:
+        from fastled.test.can_run_local_docker_tests import can_run_local_docker_tests
+
+        return can_run_local_docker_tests()
+
+    @staticmethod
+    def test_examples(
+        examples: list[str] | None = None, host: str | CompileServer | None = None
+    ) -> dict[str, Exception]:
+        from fastled.test.examples import test_examples
+
+        if isinstance(host, CompileServer):
+            host = host.url()
+
+        return test_examples(examples=examples, host=host)
+
+    @staticmethod
+    def build_site(outputdir: Path, fast: bool | None = None, check: bool = True):
+        """Builds the FastLED compiler site."""
+        build(outputdir=outputdir, fast=fast, check=check)
+
+
+__all__ = [
+    "Api",
+    "Test",
+    "Build",
+    "CompileServer",
+    "CompileResult",
+    "CompileServerError",
+    "BuildMode",
+]

{fastled-1.2.5 → fastled-1.2.7}/src/fastled/app.py

@@ -51,6 +51,32 @@ def main() -> int:
         print("Finished updating.")
         return 0
 
+    if args.build:
+        try:
+            project_root = Path(".").absolute()
+            print(f"Building Docker image at {project_root}")
+            from fastled import Api, Docker
+
+            docker_image_name = Docker.build_from_fastled_repo(
+                project_root=project_root
+            )
+            print(f"Built Docker image: {docker_image_name}")
+            print("Running server")
+            with Api.server(
+                auto_updates=False, container_name=docker_image_name
+            ) as server:
+                print(f"Server started at {server.url()}")
+                sketch_dir = Path("examples/wasm")
+                with Api.live_client(
+                    sketch_directory=sketch_dir, host=server
+                ) as client:
+                    print(f"Client started at {client.url()}")
+                    while True:
+                        time.sleep(0.1)
+        except KeyboardInterrupt:
+            print("\nExiting from client...")
+            return 1
+
     if args.server:
         print("Running in server only mode.")
         return run_server(args)

{fastled-1.2.5 → fastled-1.2.7}/src/fastled/docker_manager.py

@@ -4,6 +4,7 @@ New abstraction for Docker management with improved Ctrl+C handling.
 
 import _thread
 import os
+import platform
 import subprocess
 import sys
 import threading
@@ -97,10 +98,12 @@ class RunningContainer:
 
 class DockerManager:
     def __init__(self) -> None:
+        from docker.errors import DockerException
+
         try:
             self._client: DockerClient | None = None
             self.first_run = False
-        except docker.errors.DockerException as e:
+        except DockerException as e:
             stack = traceback.format_exc()
             warnings.warn(f"Error initializing Docker client: {e}\n{stack}")
             raise
@@ -475,7 +478,7 @@ class DockerManager:
                     print(
                         f"Container {container_name} did not restart within {timeout} seconds."
                     )
-                    container.stop()
+                    container.stop(timeout=0)
                     print(f"Container {container_name} has been stopped.")
                     container.start()
             elif container.status == "paused":
@@ -501,6 +504,7 @@ class DockerManager:
                 tty=True,
                 volumes=volumes,
                 ports=ports,
+                remove=True,
             )
         return container
 
@@ -552,6 +556,8 @@ class DockerManager:
         if isinstance(container, str):
             container = self.get_container(container)
 
+        assert container is not None, "Container not found."
+
         print(f"Attaching to container {container.name}...")
 
         first_run = self.first_run
@@ -570,7 +576,11 @@ class DockerManager:
                 print(f"Could not put container {container_name} to sleep.")
                 return
         try:
-            container.pause()
+            if platform.system() == "Windows":
+                container.pause()
+            else:
+                container.stop()
+                container.remove()
             print(f"Container {container.name} has been suspended.")
         except KeyboardInterrupt:
             print(f"Container {container.name} interrupted by keyboard interrupt.")
@@ -583,21 +593,23 @@ class DockerManager:
         """
         if isinstance(container, str):
             container = self.get_container(container)
+        if not container:
+            print(f"Could not resume container {container}.")
+            return
         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:
+    def get_container(self, container_name: str) -> Container | None:
         """
         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
+            return None
 
     def is_container_running(self, container_name: str) -> bool:
         """
@@ -610,6 +622,67 @@ class DockerManager:
             print(f"Container {container_name} not found.")
             return False
 
+    def build_image(
+        self,
+        image_name: str,
+        tag: str,
+        dockerfile_path: Path,
+        build_context: Path,
+        build_args: dict[str, str] | None = None,
+        platform_tag: str = "",
+    ) -> None:
+        """
+        Build a Docker image from a Dockerfile.
+
+        Args:
+            image_name: Name for the image
+            tag: Tag for the image
+            dockerfile_path: Path to the Dockerfile
+            build_context: Path to the build context directory
+            build_args: Optional dictionary of build arguments
+            platform_tag: Optional platform tag (e.g. "-arm64")
+        """
+        if not dockerfile_path.exists():
+            raise FileNotFoundError(f"Dockerfile not found at {dockerfile_path}")
+
+        if not build_context.exists():
+            raise FileNotFoundError(
+                f"Build context directory not found at {build_context}"
+            )
+
+        print(f"Building Docker image {image_name}:{tag} from {dockerfile_path}")
+
+        # Prepare build arguments
+        buildargs = build_args or {}
+        if platform_tag:
+            buildargs["PLATFORM_TAG"] = platform_tag
+
+        try:
+            cmd_list = [
+                "docker",
+                "build",
+                "-t",
+                f"{image_name}:{tag}",
+            ]
+
+            # Add build args
+            for arg_name, arg_value in buildargs.items():
+                cmd_list.extend(["--build-arg", f"{arg_name}={arg_value}"])
+
+            # Add dockerfile and context paths
+            cmd_list.extend(["-f", str(dockerfile_path), str(build_context)])
+
+            cmd_str = subprocess.list2cmdline(cmd_list)
+            print(f"Running command: {cmd_str}")
+
+            # Run the build command
+            subprocess.run(cmd_list, check=True)
+            print(f"Successfully built image {image_name}:{tag}")
+
+        except subprocess.CalledProcessError as e:
+            print(f"Error building Docker image: {e}")
+            raise
+
     def purge(self, image_name: str) -> None:
         """
         Remove all containers and images associated with the given image name.
@@ -626,11 +699,13 @@ class DockerManager:
                 if any(image_name in tag for tag in container.image.tags):
                     print(f"Removing container {container.name}")
                     container.remove(force=True)
+
         except Exception as e:
             print(f"Error removing containers: {e}")
 
         # Remove all images with this name
         try:
+            self.client.images.prune(filters={"dangling": False})
             images = self.client.images.list()
             for image in images:
                 if any(image_name in tag for tag in image.tags):

{fastled-1.2.5 → fastled-1.2.7}/src/fastled/keyboard.py

@@ -6,12 +6,10 @@ import time
 from queue import Empty, Queue
 from threading import Thread
 
-_WHITE_SPACE = [" ", "\r", "\n"]
+_WHITE_SPACE = {" ", "\n", "\r"}  # Including Enter key as whitespace
 
 
-# Original space bar, but now also enter key.
 class SpaceBarWatcher:
-
     @classmethod
     def watch_space_bar_pressed(cls, timeout: float = 0) -> bool:
         watcher = cls()
@@ -32,9 +30,7 @@ class SpaceBarWatcher:
         self.process.start()
 
     def _watch_for_space(self) -> None:
-        # Set stdin to non-blocking mode
         fd = sys.stdin.fileno()
-
         if os.name == "nt":  # Windows
             import msvcrt
 
@@ -51,14 +47,13 @@ class SpaceBarWatcher:
                     char = msvcrt.getch().decode()  # type: ignore
                     if char in _WHITE_SPACE:
                         self.queue.put(ord(" "))
-
         else:  # Unix-like systems
             import termios
             import tty
 
             old_settings = termios.tcgetattr(fd)  # type: ignore
             try:
-                tty.setraw(fd)  # type: ignore
+                tty.setcbreak(fd)  # Use cbreak mode to avoid console issues
                 while True:
                     # Check for cancel signal
                     try:
@@ -70,21 +65,22 @@ class SpaceBarWatcher:
                     # Check if there's input ready
                     if select.select([sys.stdin], [], [], 0.1)[0]:
                         char = sys.stdin.read(1)
-                        if ord(char) == 3:  # ctrl+c on mac, maybe also linux?
+                        if ord(char) == 3:  # Ctrl+C
                             _thread.interrupt_main()
                             break
-
                         if char in _WHITE_SPACE:
                             self.queue.put(ord(" "))
             finally:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)  # type: ignore
+                termios.tcsetattr(
+                    fd, termios.TCSADRAIN, old_settings
+                )  # Restore terminal settings
 
     def space_bar_pressed(self) -> bool:
         found = False
         while not self.queue.empty():
             try:
-                key = self.queue.get(block=False, timeout=0.1)
-                if key == ord(" "):
+                key = self.queue.get(block=False)
+                if key == ord(" "):  # Spacebar
                     found = True
                 self.queue.task_done()
             except Empty:

{fastled-1.2.5 → fastled-1.2.7}/src/fastled/live_client.py

@@ -45,6 +45,17 @@ class LiveClient:
         )
         return rtn
 
+    def url(self) -> str:
+        """Get the URL of the server."""
+        if isinstance(self.host, CompileServer):
+            return self.host.url()
+        if self.host is None:
+            import warnings
+
+            warnings.warn("TODO: use the actual host.")
+            return "http://localhost:9021"
+        return self.host
+
     @property
     def running(self) -> bool:
         return self.thread is not None and self.thread.is_alive()
@@ -67,3 +78,9 @@ class LiveClient:
         """Finalize the client."""
         self.stop()
         self.thread = None
+
+    def __enter__(self) -> "LiveClient":
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        self.finalize()

{fastled-1.2.5 → fastled-1.2.7}/src/fastled/open_browser.py

@@ -17,7 +17,8 @@ def _open_browser_python(fastled_js: Path) -> None:
         subprocess.run(
             [sys.executable, "-m", "nodejs.npm", "install", "-g", "live-server"]
         )
-    os.system(f"cd {fastled_js} && live-server")
+    proc = subprocess.Popen(["cd", fastled_js, "&&", "live-server"])
+    proc.wait()
 
 
 def _find_open_port(start_port: int) -> int: