fastled 1.2.4__tar.gz → 1.2.6__tar.gz

{fastled-1.2.4 → fastled-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastled
-Version: 1.2.4
+Version: 1.2.6
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -266,6 +266,8 @@ A: A big chunk of space is being used by unnecessary javascript `emscripten` bun
 
 # Revisions
 
+  * 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.
   * 1.2.22 - Added `--purge` and added docker api at __init__.

{fastled-1.2.4 → fastled-1.2.6}/README.md

@@ -243,6 +243,8 @@ A: A big chunk of space is being used by unnecessary javascript `emscripten` bun
 
 # Revisions
 
+  * 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.
   * 1.2.22 - Added `--purge` and added docker api at __init__.

{fastled-1.2.4 → fastled-1.2.6}/src/fastled/__init__.py

@@ -13,7 +13,7 @@ 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.4"
+__version__ = "1.2.6"
 
 
 class Api:
@@ -131,17 +131,141 @@ class Docker:
         from fastled.docker_manager import DockerManager
         from fastled.settings import CONTAINER_NAME
 
-        docker = DockerManager()
+        docker_mgr = DockerManager()
         container_name = container_name or CONTAINER_NAME
-        return docker.is_container_running(container_name)
+        return docker_mgr.is_container_running(container_name)
 
     @staticmethod
     def purge() -> None:
         from fastled.docker_manager import DockerManager
         from fastled.settings import CONTAINER_NAME
 
-        docker = DockerManager()
-        docker.purge(CONTAINER_NAME)
+        docker_mgr = DockerManager()
+        docker_mgr.purge(CONTAINER_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.
+        """
+        import subprocess
+
+        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()
+
+        # 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"},
+        )
+
+        # 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 "latest".
+
+        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()
+
+        # 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:
@@ -173,6 +297,7 @@ class Test:
 __all__ = [
     "Api",
     "Test",
+    "Build",
     "CompileServer",
     "CompileResult",
     "CompileServerError",

{fastled-1.2.4 → fastled-1.2.6}/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.4 → fastled-1.2.6}/src/fastled/docker_manager.py

@@ -97,10 +97,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
@@ -610,6 +612,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.

{fastled-1.2.4 → fastled-1.2.6}/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.4 → fastled-1.2.6}/src/fastled/parse_args.py

@@ -79,6 +79,12 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Use localhost for web compilation from an instance of fastled --server, creating it if necessary",
     )
+    parser.add_argument(
+        "--build",
+        "-b",
+        action="store_true",
+        help="Build the wasm compiler image from the FastLED repo",
+    )
     parser.add_argument(
         "--server",
         "-s",
@@ -116,7 +122,11 @@ def parse_args() -> argparse.Namespace:
 
     if args.init:
         example = args.init if args.init is not True else None
-        args.directory = project_init(example, args.directory)
+        try:
+            args.directory = project_init(example, args.directory)
+        except Exception as e:
+            print(f"Failed to initialize project: {e}")
+            sys.exit(1)
         print("\nInitialized FastLED project in", args.directory)
         print(f"Use 'fastled {args.directory}' to compile the project.")
         sys.exit(0)

{fastled-1.2.4 → fastled-1.2.6}/src/fastled/project_init.py

@@ -1,9 +1,13 @@
+import _thread
+import threading
+import time
 import zipfile
 from pathlib import Path
 
 import httpx
 
 from fastled.settings import DEFAULT_URL
+from fastled.spinner import Spinner
 
 DEFAULT_EXAMPLE = "wasm"
 
@@ -34,6 +38,35 @@ def _prompt_for_example() -> str:
             return answer
 
 
+class DownloadThread(threading.Thread):
+    def __init__(self, url: str, json: str):
+        super().__init__(daemon=True)
+        self.url = url
+        self.json = json
+        self.bytes_downloaded = 0
+        self.content: bytes | None = None
+        self.error: Exception | None = None
+        self.success = False
+
+    def run(self) -> None:
+        timeout = httpx.Timeout(5.0, connect=5.0, read=120.0, write=30.0)
+        try:
+            with httpx.Client(timeout=timeout) as client:
+                with client.stream("POST", self.url, json=self.json) as response:
+                    response.raise_for_status()
+                    content = b""
+                    for chunk in response.iter_bytes():
+                        content += chunk
+                        self.bytes_downloaded += len(chunk)
+                    self.content = content
+                    self.success = True
+        except KeyboardInterrupt:
+            self.error = RuntimeError("Download cancelled")
+            _thread.interrupt_main()
+        except Exception as e:
+            self.error = e
+
+
 def project_init(
     example: str | None = "PROMPT",  # prompt for example
     outputdir: Path | None = None,
@@ -56,9 +89,26 @@ def project_init(
     assert example is not None
     endpoint_url = f"{host}/project/init"
     json = example
-    response = httpx.post(endpoint_url, timeout=20, json=json)
-    response.raise_for_status()
-    content = response.content
+    print(f"Initializing project with example '{example}', url={endpoint_url}")
+
+    # Start download thread
+    download_thread = DownloadThread(endpoint_url, json)
+    # spinner = Spinner("Downloading project...")
+    with Spinner(f"Downloading project {example}..."):
+        download_thread.start()
+        while download_thread.is_alive():
+            time.sleep(0.1)
+
+    print()  # New line after progress
+    download_thread.join()
+
+    # Check for errors
+    if not download_thread.success:
+        assert download_thread.error is not None
+        raise download_thread.error
+
+    content = download_thread.content
+    assert content is not None
     tmpzip = outputdir / "fastled.zip"
     outputdir.mkdir(exist_ok=True)
     tmpzip.write_bytes(content)

{fastled-1.2.4 → fastled-1.2.6}/src/fastled/site/build.py

@@ -302,9 +302,9 @@ EXAMPLES = [
     "wasm",
     "Chromancer",
     "LuminescentGrand",
-    "fx/SdCard",
-    "fx/NoiseRing",
-    "fx/Water",
+    "FxSdCard",
+    "FxNoiseRing",
+    "FxWater",
 ]
 
 

{fastled-1.2.4 → fastled-1.2.6}/src/fastled.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastled
-Version: 1.2.4
+Version: 1.2.6
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -266,6 +266,8 @@ A: A big chunk of space is being used by unnecessary javascript `emscripten` bun
 
 # Revisions
 
+  * 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.
   * 1.2.22 - Added `--purge` and added docker api at __init__.

{fastled-1.2.4 → fastled-1.2.6}/src/fastled.egg-info/SOURCES.txt

@@ -61,6 +61,7 @@ src/fastled/test/can_run_local_docker_tests.py
 src/fastled/test/examples.py
 tests/test_api.py
 tests/test_bad_ino.py
+tests/test_build.py
 tests/test_build_examples.py
 tests/test_cli.py
 tests/test_compile_server.py

fastled-1.2.6/tests/test_build.py

@@ -0,0 +1,57 @@
+"""
+Unit test file.
+"""
+
+import unittest
+from pathlib import Path
+
+from fastled import Api, CompileServer, Docker, Test  # type: ignore
+
+HERE = Path(__file__).parent
+PROJECT_ROOT = HERE.parent
+FASTLED_SISTER_REPO = PROJECT_ROOT / ".." / "FastLED"
+
+DEFAULT_GITHUB_URL = "https://github.com/fastled/fastled"
+OUTPUT_DIR = Path(".cache/fastled")
+
+
+def _enabled() -> bool:
+    """Check if this system can run the tests."""
+    sister_repo_does_not_exist = not FASTLED_SISTER_REPO.exists()
+
+    if sister_repo_does_not_exist:
+        print(
+            f"This test is only enable when FastLED is a repo in the same directly as the project root folder: {FASTLED_SISTER_REPO} does not exist"
+        )
+        return False
+
+    return Test.can_run_local_docker_tests()
+
+
+class BuildDockerFromRepoTester(unittest.TestCase):
+    """Main tester class."""
+
+    @unittest.skipUnless(_enabled(), "Skipping test on non-Linux system on github")
+    def test_build_docker(self) -> None:
+        """Builds the docker file from the fastled repo."""
+
+        docker_image_name = Docker.build_from_fastled_repo(FASTLED_SISTER_REPO)
+        self.assertTrue(docker_image_name, "Failed to build docker image")
+        server: CompileServer
+        with Api.server(auto_updates=True, container_name=docker_image_name) as server:
+            self.assertTrue(server.ping())
+
+    @unittest.skipUnless(_enabled(), "Skipping test on non-Linux system on github")
+    def test_build_docker_from_github(self) -> None:
+        """Builds the docker file from the fastled repo."""
+        url = DEFAULT_GITHUB_URL
+        print("Building from github")
+        docker_image_name = Docker.build_from_github(url=url, output_dir=OUTPUT_DIR)
+        self.assertTrue(docker_image_name, "Failed to build docker image")
+        server: CompileServer
+        with Api.server(auto_updates=True, container_name=docker_image_name) as server:
+            self.assertTrue(server.ping())
+
+
+if __name__ == "__main__":
+    unittest.main()

{fastled-1.2.4 → fastled-1.2.6}/tests/test_examples.py

@@ -10,7 +10,7 @@ HERE = Path(__file__).parent
 TEST_DIR = HERE / "test_ino" / "wasm"
 
 
-EXAMPLES = ["Blink", "wasm", "Chromancer", "fx/SdCard", "fx/NoiseRing"]
+EXAMPLES = ["Blink", "wasm", "Chromancer", "FxSdCard", "FxNoiseRing"]
 
 
 def _enabled() -> bool: