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

fastled/__init__.py

@@ -1,22 +1,17 @@
 """FastLED Wasm Compiler package."""
 
-# context
-import shutil
-import subprocess
 from contextlib import contextmanager
 from multiprocessing import Process
 from pathlib import Path
 from typing import Generator
 
+from .__version__ import __version__
 from .compile_server import CompileServer
+from .emoji_util import EMO
 from .live_client import LiveClient
+from .settings import DOCKER_FILE, IMAGE_NAME
 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.33"
+from .types import BuildMode, CompileResult, CompileServerError, FileResponse
 
 
 class Api:
@@ -45,15 +40,31 @@ class Api:
         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.
+        no_platformio: bool = False,
     ) -> CompileResult:
+        from fastled.sketch import looks_like_fastled_repo
         from fastled.web_compile import web_compile
 
         if isinstance(host, CompileServer):
             host = host.url()
         if isinstance(directory, str):
             directory = Path(directory)
+
+        # Guard: libfastled compilation requires volume source mapping
+        # Only allow libcompile if we're in a FastLED repository
+        allow_libcompile = looks_like_fastled_repo(Path(".").resolve())
+        if not allow_libcompile:
+            print(
+                f"{EMO('⚠️', 'WARNING:')}  libfastled compilation disabled: not running in FastLED repository"
+            )
+
         out: CompileResult = web_compile(
-            directory, host, build_mode=build_mode, profile=profile
+            directory,
+            host,
+            build_mode=build_mode,
+            profile=profile,
+            no_platformio=no_platformio,
+            allow_libcompile=allow_libcompile,
         )
         return out
 
@@ -67,6 +78,11 @@ class Api:
         keep_running=True,
         build_mode=BuildMode.QUICK,
         profile=False,
+        http_port: (
+            int | None
+        ) = None,  # None means auto select a free port. -1 means no server.
+        no_platformio: bool = False,
+        enable_https: bool = True,  # Enable HTTPS for the local server
     ) -> LiveClient:
         return LiveClient(
             sketch_directory=sketch_directory,
@@ -77,6 +93,9 @@ class Api:
             keep_running=keep_running,
             build_mode=build_mode,
             profile=profile,
+            http_port=http_port,
+            no_platformio=no_platformio,
+            enable_https=enable_https,
         )
 
     @staticmethod
@@ -87,9 +106,9 @@ class Api:
         mapped_dir: Path | None = None,  # Sketch directory.
         container_name: str | None = None,  # Specific docker container name.
         remove_previous: bool = False,
+        no_platformio: bool = False,
     ) -> CompileServer:
         """Uses docker to spawn a compile server from the given name."""
-        from fastled.compile_server import CompileServer
 
         out = CompileServer(
             container_name=container_name,
@@ -98,6 +117,7 @@ class Api:
             mapped_dir=mapped_dir,
             auto_start=auto_start,
             remove_previous=remove_previous,
+            no_platformio=no_platformio,
         )
         return out
 
@@ -110,6 +130,7 @@ class Api:
         mapped_dir: Path | None = None,  # Sketch directory.
         container_name: str | None = None,  # Specific docker container name.
         remove_previous=False,
+        no_platformio: bool = False,
     ) -> Generator[CompileServer, None, None]:
         server = Api.spawn_server(
             interactive=interactive,
@@ -118,6 +139,7 @@ class Api:
             mapped_dir=mapped_dir,
             container_name=container_name,
             remove_previous=remove_previous,
+            no_platformio=no_platformio,
         )
         try:
             yield server
@@ -136,7 +158,9 @@ class Docker:
     def is_running() -> bool:
         from fastled.docker_manager import DockerManager
 
-        return DockerManager.is_running()
+        ok: bool
+        ok, _ = DockerManager.is_running()
+        return ok
 
     @staticmethod
     def is_container_running(container_name: str | None = None) -> bool:
@@ -151,186 +175,10 @@ class Docker:
     @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)
-
-        git_dir = output_dir / ".git"
-        library_properties = output_dir / "library.properties"
-
-        git_dir_exists = git_dir.exists()
-        library_properties_exists = library_properties.exists()
-        library_properties_text = (
-            library_properties.read_text().strip() if library_properties_exists else ""
-        )
-
-        already_exists = (
-            git_dir_exists
-            and library_properties_exists
-            and "FastLED" in library_properties_text
-        )
-        if git_dir_exists and not already_exists:
-            if ".cache/fastled" in str(output_dir.as_posix()):
-                shutil.rmtree(output_dir)
-                already_exists = False
-            else:
-                raise ValueError(
-                    f"Output directory {output_dir} already exists but does not appear to be a FastLED repository."
-                )
-
-        # Clone or update the repository
-        if already_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=False,
-                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", "--depth", "1", 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  # Todo, create an external docker container api.
-
-    @staticmethod
-    def build_from_fastled_repo(
-        project_root: Path | str = Path("."),
-        interactive: bool = False,
-        sketch_folder: Path | None = None,
-    ) -> CompileServer:
-        """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
-
-        project_root = Path(project_root)
-        if interactive:
-            if sketch_folder is None:
-                sketch_folder = project_root / "examples" / "wasm"
-        else:
-            if sketch_folder is not None:
-                raise ValueError(
-                    "Cannot specify sketch_folder when not in interactive mode."
-                )
-        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,
-        )
-
-        out: CompileServer = CompileServer(
-            container_name=CONTAINER_NAME,
-            interactive=interactive,
-            auto_updates=False,
-            mapped_dir=sketch_folder,
-            auto_start=True,
-            remove_previous=True,
-        )
-
-        return out
-
 
 class Tools:
     @staticmethod
@@ -370,14 +218,23 @@ class Test:
     def spawn_http_server(
         directory: Path | str = Path("."),
         port: int | None = None,
+        compile_server_port: int | None = None,
         open_browser: bool = True,
+        app: bool = False,
+        enable_https: bool = False,  # Default to HTTP for tests (tests use http:// URLs)
     ) -> Process:
-        from fastled.open_browser import open_browser_process
+        from fastled.open_browser import spawn_http_server
 
+        compile_server_port = compile_server_port or -1
         if isinstance(directory, str):
             directory = Path(directory)
-        proc: Process = open_browser_process(
-            directory, port=port, open_browser=open_browser
+        proc: Process = spawn_http_server(
+            directory,
+            port=port,
+            compile_server_port=compile_server_port,
+            open_browser=open_browser,
+            app=app,
+            enable_https=enable_https,
         )
         return proc
 
@@ -385,9 +242,11 @@ class Test:
 __all__ = [
     "Api",
     "Test",
-    "Build",
     "CompileServer",
     "CompileResult",
     "CompileServerError",
     "BuildMode",
+    "FileResponse",
+    "DOCKER_FILE",
+    "__version__",
 ]

fastled/__main__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+"""
+FastLED Package Main Entry Point
+Enables running the package as: python -m fastled
+"""
+
+import sys
+
+from fastled.cli import main
+
+if __name__ == "__main__":
+    # Pass execution to the main function from cli.py
+    # This enables 'python -m fastled' to work the same as 'fastled' command
+    sys.exit(main())

fastled/__version__.py

@@ -0,0 +1,6 @@
+# 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.4.50"
+
+__version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

fastled/app.py

@@ -2,18 +2,21 @@
 Uses the latest wasm compiler image to compile the FastLED sketch.
 """
 
-import argparse
+import os
 import sys
 import time
 from pathlib import Path
 
 from fastled.client_server import run_client_server
 from fastled.compile_server import CompileServer
+from fastled.emoji_util import EMO
 from fastled.filewatcher import file_watcher_set
-from fastled.parse_args import parse_args
+from fastled.parse_args import Args, parse_args
+from fastled.settings import DEFAULT_URL
+from fastled.sketch import find_sketch_directories, looks_like_fastled_repo
 
 
-def run_server(args: argparse.Namespace) -> int:
+def run_server(args: Args) -> int:
     interactive = args.interactive
     auto_update = args.auto_update
     mapped_dir = Path(args.directory).absolute() if args.directory else None
@@ -25,6 +28,8 @@ def run_server(args: argparse.Namespace) -> int:
         auto_updates=auto_update,
         mapped_dir=mapped_dir,
         auto_start=True,
+        remove_previous=args.clear,
+        no_platformio=args.no_platformio,
     )
 
     if not interactive:
@@ -44,41 +49,129 @@ def run_server(args: argparse.Namespace) -> int:
 
 
 def main() -> int:
+    from fastled import __version__
+    from fastled.select_sketch_directory import select_sketch_directory
+
     args = parse_args()
+
+    if args.emsdk_headers:
+        import httpx
+
+        out_path = args.emsdk_headers
+        base_url = args.web if isinstance(args.web, str) else DEFAULT_URL
+        try:
+            response = httpx.get(f"{base_url}/headers/emsdk")
+            if response.status_code == 200:
+                Path(out_path).parent.mkdir(parents=True, exist_ok=True)
+                with open(out_path, "wb") as f:
+                    f.write(response.content)
+                print(f"{EMO('✅','SUCCESS:')} EMSDK headers exported to {out_path}")
+                return 0
+            else:
+                print(
+                    f"{EMO('❌','ERROR:')} Failed to export EMSDK headers: HTTP {response.status_code}"
+                )
+                return 1
+        except KeyboardInterrupt:
+            print("\nExiting from main...")
+            return 1
+        except Exception as e:
+            print(f"{EMO('❌','ERROR:')} Exception: {e}")
+            return 1
+
+    # Handle --install command early
+    if args.install:
+        from fastled.install.main import fastled_install
+
+        result = fastled_install(
+            dry_run=args.dry_run, no_interactive=args.no_interactive
+        )
+        return 0 if result else 1
+
     interactive: bool = args.interactive
-    server: str | CompileServer | None = args.server
+    has_server = args.server
     update: bool = args.update
     build: bool = args.build
     just_compile: bool = args.just_compile
     # directory: Path | None = Path(args.directory).absolute() if args.directory else None
     directory: Path | None = Path(args.directory) if args.directory else None
-
-    # broken for now
-    if directory is None and interactive:
-        # if examples/wasm exists
-        if Path("examples/wasm").exists():
-            print(f"Using {Path('examples/wasm')} as the sketch directory")
-            directory = Path("examples/wasm").absolute()
+    cwd_looks_like_fastled_repo = looks_like_fastled_repo()
+
+    # now it is safe to print out the version
+    print(f"FastLED version: {__version__}")
+
+    # Print current working directory
+    print(f"Current working directory: {os.getcwd()}")
+
+    # Check if Playwright browsers are installed
+    playwright_dir = Path.home() / ".fastled" / "playwright"
+    if playwright_dir.exists() and any(playwright_dir.iterdir()):
+        print(f"{EMO('🎭', '*')} Playwright browsers available at: {playwright_dir}")
+
+    # Resolve some of the last interactive arguments
+    # 1. If interactive is set and the sketch directory is not given,
+    # then prompt the user for a sketch directory.
+    # 2. Tell the user they can use --server --interactive to
+    # skip this prompt.
+    if interactive and cwd_looks_like_fastled_repo and directory is None:
+        answer = input(
+            "No sketch directory selected, would you like to select one? (y/n): "
+        )
+        if answer.lower()[:1] == "y" or answer.lower() == "":
+            sketch_list: list[Path] = find_sketch_directories()
+            if sketch_list:
+                maybe_dir: str | None = select_sketch_directory(
+                    sketch_list, cwd_looks_like_fastled_repo, is_followup=True
+                )
+                if maybe_dir is not None:
+                    directory = Path(maybe_dir)
+                    if not directory.exists():
+                        print(
+                            f"Directory {directory} does not exist, entering interactive mode without project mapped in."
+                        )
+                        directory = None
 
     if update:
         # Force auto_update to ensure update check happens
-        compile_server = CompileServer(interactive=False, auto_updates=True)
+        compile_server = CompileServer(
+            interactive=False, auto_updates=True, no_platformio=args.no_platformio
+        )
         compile_server.stop()
         print("Finished updating.")
         return 0
 
     if build:
-        try:
-            file_watcher_set(False)
-            project_root = Path(".").absolute()
-            print(f"Building Docker image at {project_root}")
-            from fastled import Api, Docker
+        print("Building is disabled")
+        build = False
+
+    if interactive:
+        # raise NotImplementedError("Building is not yet supported.")
+        file_watcher_set(False)
+        # project_root = Path(".").absolute()
+        # print(f"Building Docker image at {project_root}")
+        from fastled import Api
+
+        server: CompileServer = CompileServer(
+            interactive=interactive,
+            auto_updates=False,
+            mapped_dir=directory,
+            auto_start=False,
+            remove_previous=args.clear,
+            no_platformio=args.no_platformio,
+        )
+
+        server.start(wait_for_startup=False)
 
-            server = Docker.build_from_fastled_repo(
-                project_root=project_root, interactive=interactive
-            )
-            assert isinstance(server, CompileServer)
+        try:
+            while server.process_running():
+                # wait for ctrl-c
+                time.sleep(0.1)
+        except KeyboardInterrupt:
+            print("\nExiting from server...")
+            server.stop()
+            return 0
 
+        try:
             if interactive:
                 server.stop()
                 return 0
@@ -90,20 +183,22 @@ def main() -> int:
                 return 0
 
             print("Running server")
+
             with Api.live_client(
                 auto_updates=False,
                 sketch_directory=directory,
                 host=server,
                 auto_start=True,
                 keep_running=not just_compile,
-            ) as client:
-                print(f"Exited client {client.url()}")
-                print(f"Exiting {server.name}")
+            ) as _:
+                while True:
+                    time.sleep(0.2)  # wait for user to exit
         except KeyboardInterrupt:
             print("\nExiting from client...")
+            server.stop()
             return 1
 
-    if server:
+    if has_server:
         print("Running in server only mode.")
         return run_server(args)
     else:
@@ -114,12 +209,14 @@ def main() -> int:
 if __name__ == "__main__":
     # Note that the entry point for the exe is in cli.py
     try:
-        sys.argv.append("-b")
-        sys.argv.append("examples/wasm")
+        # sys.argv.append("-i")
+        # sys.argv.append("-b")
+        # sys.argv.append("examples/wasm")
         # sys.argv.append()
         import os
 
         os.chdir("../fastled")
+        sys.argv.append("examples/FxWave2d")
         sys.exit(main())
     except KeyboardInterrupt:
         print("\nExiting from main...")