fastled 1.1.45__py3-none-any.whl

fastled/__init__.py

@@ -0,0 +1,128 @@
+"""FastLED Wasm Compiler package."""
+
+# context
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Generator
+
+from .compile_server import CompileServer
+from .live_client import LiveClient
+from .types import BuildMode, CompileResult, CompileServerError
+
+__version__ = "1.1.45"
+
+
+class Api:
+    @staticmethod
+    def get_examples():
+        from fastled.project_init import get_examples
+
+        return get_examples()
+
+    @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 Test:
+    @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)
+
+
+__all__ = [
+    "Api",
+    "Test",
+    "CompileServer",
+    "CompileResult",
+    "CompileServerError",
+    "BuildMode",
+]

fastled/app.py

@@ -0,0 +1,67 @@
+"""
+Uses the latest wasm compiler image to compile the FastLED sketch.
+"""
+
+import argparse
+import sys
+import time
+from pathlib import Path
+
+from fastled.client_server import run_client_server
+from fastled.compile_server import CompileServer
+from fastled.parse_args import parse_args
+
+
+def run_server(args: argparse.Namespace) -> int:
+    interactive = args.interactive
+    auto_update = args.auto_update
+    mapped_dir = Path(args.directory).absolute() if args.directory else None
+    compile_server = CompileServer(
+        interactive=interactive,
+        auto_updates=auto_update,
+        mapped_dir=mapped_dir,
+        auto_start=True,
+    )
+
+    if not interactive:
+        print(f"Server started at {compile_server.url()}")
+    try:
+        while True:
+            if not compile_server.process_running():
+                print("Server process is not running. Exiting...")
+                return 1
+            time.sleep(0.1)
+    except KeyboardInterrupt:
+        print("\nExiting from server...")
+        return 1
+    finally:
+        compile_server.stop()
+    return 0
+
+
+def main() -> int:
+    args = parse_args()
+    if args.update:
+        # Force auto_update to ensure update check happens
+        compile_server = CompileServer(interactive=False, auto_updates=True)
+        compile_server.stop()
+        print("Finished updating.")
+        return 0
+
+    if args.server:
+        print("Running in server only mode.")
+        return run_server(args)
+    else:
+        print("Running in client/server mode.")
+        return run_client_server(args)
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except KeyboardInterrupt:
+        print("\nExiting from main...")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)

fastled/assets/example.txt

@@ -0,0 +1 @@
+Example assets that will be deployed with python code.

fastled/cli.py

@@ -0,0 +1,16 @@
+"""
+Main entry point.
+"""
+
+import sys
+
+from fastled.app import main as app_main
+
+
+def main() -> int:
+    """Main entry point for the template_python_cmd package."""
+    return app_main()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fastled/client_server.py

@@ -0,0 +1,351 @@
+import argparse
+import shutil
+import tempfile
+import threading
+import time
+from multiprocessing import Process
+from pathlib import Path
+
+from fastled.compile_server import CompileServer
+from fastled.docker_manager import DockerManager
+from fastled.filewatcher import FileWatcherProcess
+from fastled.keyboard import SpaceBarWatcher
+from fastled.open_browser import open_browser_process
+from fastled.settings import DEFAULT_URL
+from fastled.sketch import looks_like_sketch_directory
+from fastled.types import BuildMode, CompileResult, CompileServerError
+from fastled.web_compile import (
+    SERVER_PORT,
+    ConnectionResult,
+    find_good_connection,
+    web_compile,
+)
+
+
+# Override this function in your own code to run tests before compilation
+def TEST_BEFORE_COMPILE(url) -> None:
+    pass
+
+
+def _run_web_compiler(
+    directory: Path,
+    host: str,
+    build_mode: BuildMode,
+    profile: bool,
+    last_hash_value: str | None,
+) -> CompileResult:
+    input_dir = Path(directory)
+    output_dir = input_dir / "fastled_js"
+    start = time.time()
+    web_result = web_compile(
+        directory=input_dir, host=host, build_mode=build_mode, profile=profile
+    )
+    diff = time.time() - start
+    if not web_result.success:
+        print("\nWeb compilation failed:")
+        print(f"Time taken: {diff:.2f} seconds")
+        print(web_result.stdout)
+        return web_result
+
+    def print_results() -> None:
+        hash_value = (
+            web_result.hash_value
+            if web_result.hash_value is not None
+            else "NO HASH VALUE"
+        )
+        print(
+            f"\nWeb compilation successful\n  Time: {diff:.2f}\n  output: {output_dir}\n  hash: {hash_value}\n  zip size: {len(web_result.zip_bytes)} bytes"
+        )
+
+    # now check to see if the hash value is the same as the last hash value
+    if last_hash_value is not None and last_hash_value == web_result.hash_value:
+        print("\nSkipping redeploy: No significant changes found.")
+        print_results()
+        return web_result
+
+    # Extract zip contents to fastled_js directory
+    output_dir.mkdir(exist_ok=True)
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+        temp_zip = temp_path / "result.zip"
+        temp_zip.write_bytes(web_result.zip_bytes)
+
+        # Clear existing contents
+        shutil.rmtree(output_dir, ignore_errors=True)
+        output_dir.mkdir(exist_ok=True)
+
+        # Extract zip contents
+        shutil.unpack_archive(temp_zip, output_dir, "zip")
+
+    print(web_result.stdout)
+    print_results()
+    return web_result
+
+
+def _try_start_server_or_get_url(
+    auto_update: bool, args_web: str | bool, localhost: bool
+) -> tuple[str, CompileServer | None]:
+    is_local_host = localhost or (
+        isinstance(args_web, str)
+        and ("localhost" in args_web or "127.0.0.1" in args_web)
+    )
+    # test to see if there is already a local host server
+    local_host_needs_server = False
+    if is_local_host:
+        addr = "localhost" if localhost or not isinstance(args_web, str) else args_web
+        urls = [addr]
+        if ":" not in addr:
+            urls.append(f"{addr}:{SERVER_PORT}")
+
+        result: ConnectionResult | None = find_good_connection(urls)
+        if result is not None:
+            print(f"Found local server at {result.host}")
+            return (result.host, None)
+        else:
+            local_host_needs_server = True
+
+    if not local_host_needs_server and args_web:
+        if isinstance(args_web, str):
+            return (args_web, None)
+        if isinstance(args_web, bool):
+            return (DEFAULT_URL, None)
+        return (args_web, None)
+    else:
+        try:
+            print("No local server found, starting one...")
+            compile_server = CompileServer(auto_updates=auto_update)
+            print("Waiting for the local compiler to start...")
+            if not compile_server.ping():
+                print("Failed to start local compiler.")
+                raise CompileServerError("Failed to start local compiler.")
+            return (compile_server.url(), compile_server)
+        except KeyboardInterrupt:
+            raise
+        except RuntimeError:
+            print("Failed to start local compile server, using web compiler instead.")
+            return (DEFAULT_URL, None)
+
+
+def run_client(
+    directory: Path,
+    host: str | CompileServer | None,
+    open_web_browser: bool = True,
+    keep_running: bool = True,  # if false, only one compilation will be done.
+    build_mode: BuildMode = BuildMode.QUICK,
+    profile: bool = False,
+    shutdown: threading.Event | None = None,
+) -> int:
+
+    compile_server: CompileServer | None = (
+        host if isinstance(host, CompileServer) else None
+    )
+    shutdown = shutdown or threading.Event()
+
+    def get_url() -> str:
+        if compile_server is not None:
+            return compile_server.url()
+        if isinstance(host, str):
+            return host
+        return DEFAULT_URL
+
+    url = get_url()
+
+    try:
+
+        def compile_function(
+            url: str = url,
+            build_mode: BuildMode = build_mode,
+            profile: bool = profile,
+            last_hash_value: str | None = None,
+        ) -> CompileResult:
+            TEST_BEFORE_COMPILE(url)
+            return _run_web_compiler(
+                directory,
+                host=url,
+                build_mode=build_mode,
+                profile=profile,
+                last_hash_value=last_hash_value,
+            )
+
+        result: CompileResult = compile_function(last_hash_value=None)
+        last_compiled_result: CompileResult = result
+
+        if not result.success:
+            print("\nCompilation failed.")
+
+        browser_proc: Process | None = None
+        if open_web_browser:
+            browser_proc = open_browser_process(directory / "fastled_js")
+        else:
+            print("\nCompilation successful.")
+            if compile_server:
+                print("Shutting down compile server...")
+                compile_server.stop()
+            return 0
+
+        if not keep_running or shutdown.is_set():
+            if browser_proc:
+                browser_proc.kill()
+            return 0 if result.success else 1
+    except KeyboardInterrupt:
+        print("\nExiting from main")
+        return 1
+
+    sketch_filewatcher = FileWatcherProcess(directory, excluded_patterns=["fastled_js"])
+
+    source_code_watcher: FileWatcherProcess | None = None
+    if compile_server and compile_server.using_fastled_src_dir_volume():
+        assert compile_server.fastled_src_dir is not None
+        source_code_watcher = FileWatcherProcess(
+            compile_server.fastled_src_dir, excluded_patterns=[]
+        )
+
+    def trigger_rebuild_if_sketch_changed(
+        last_compiled_result: CompileResult,
+    ) -> tuple[bool, CompileResult]:
+        changed_files = sketch_filewatcher.get_all_changes()
+        if changed_files:
+            print(f"\nChanges detected in {changed_files}")
+            last_hash_value = last_compiled_result.hash_value
+            out = compile_function(last_hash_value=last_hash_value)
+            if not out.success:
+                print("\nRecompilation failed.")
+            else:
+                print("\nRecompilation successful.")
+            return True, out
+        return False, last_compiled_result
+
+    def print_status() -> None:
+        print("Will compile on sketch changes or if you hit the space bar.")
+
+    print_status()
+    print("Press Ctrl+C to stop...")
+
+    try:
+        while True:
+            if shutdown.is_set():
+                print("\nStopping watch mode...")
+                return 0
+            if SpaceBarWatcher.watch_space_bar_pressed(timeout=1.0):
+                print("Compiling...")
+                last_compiled_result = compile_function(last_hash_value=None)
+                if not last_compiled_result.success:
+                    print("\nRecompilation failed.")
+                else:
+                    print("\nRecompilation successful.")
+                # drain the space bar queue
+                SpaceBarWatcher.watch_space_bar_pressed()
+                print_status()
+                continue
+            changed, last_compiled_result = trigger_rebuild_if_sketch_changed(
+                last_compiled_result
+            )
+            if changed:
+                print_status()
+                continue
+            if compile_server and not compile_server.process_running():
+                print("Server process is not running. Exiting...")
+                return 1
+            if source_code_watcher is not None:
+                changed_files = source_code_watcher.get_all_changes()
+                # de-duplicate changes
+                changed_files = sorted(list(set(changed_files)))
+                if changed_files:
+                    print(f"\nChanges detected in FastLED source code: {changed_files}")
+                    print("Press space bar to trigger compile.")
+                    while True:
+                        space_bar_pressed = SpaceBarWatcher.watch_space_bar_pressed(
+                            timeout=1.0
+                        )
+                        file_changes = source_code_watcher.get_all_changes()
+                        sketch_files_changed = sketch_filewatcher.get_all_changes()
+
+                        if file_changes:
+                            print(
+                                f"Changes detected in {file_changes}\nHit the space bar to trigger compile."
+                            )
+
+                        if space_bar_pressed or sketch_files_changed:
+                            if space_bar_pressed:
+                                print("Space bar pressed, triggering recompile...")
+                            elif sketch_files_changed:
+                                print(
+                                    f"Changes detected in {','.join(sketch_files_changed)}, triggering recompile..."
+                                )
+                            last_compiled_result = compile_function(
+                                last_hash_value=None
+                            )
+                            print("Finished recompile.")
+                            # Drain the space bar queue
+                            SpaceBarWatcher.watch_space_bar_pressed()
+                            print_status()
+                            continue
+
+    except KeyboardInterrupt:
+        print("\nStopping watch mode...")
+        return 0
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+    finally:
+        sketch_filewatcher.stop()
+        if compile_server:
+            compile_server.stop()
+        if browser_proc:
+            browser_proc.kill()
+
+
+def run_client_server(args: argparse.Namespace) -> int:
+    profile = bool(args.profile)
+    web: str | bool = args.web if isinstance(args.web, str) else bool(args.web)
+    auto_update = bool(args.auto_update)
+    localhost = bool(args.localhost)
+    directory = Path(args.directory)
+    just_compile = bool(args.just_compile)
+    interactive = bool(args.interactive)
+    force_compile = bool(args.force_compile)
+    open_web_browser = not just_compile and not interactive
+    build_mode: BuildMode = BuildMode.from_args(args)
+
+    if not force_compile and not looks_like_sketch_directory(directory):
+        print(
+            "Error: Not a valid FastLED sketch directory, if you are sure it is, use --force-compile"
+        )
+        return 1
+
+    # If not explicitly using web compiler, check Docker installation
+    if not web and not DockerManager.is_docker_installed():
+        print(
+            "\nDocker is not installed on this system - switching to web compiler instead."
+        )
+        web = True
+
+    url: str
+    compile_server: CompileServer | None = None
+    try:
+        url, compile_server = _try_start_server_or_get_url(auto_update, web, localhost)
+    except KeyboardInterrupt:
+        print("\nExiting from first try...")
+        if compile_server:
+            compile_server.stop()
+        return 1
+    except Exception as e:
+        print(f"Error: {e}")
+        if compile_server:
+            compile_server.stop()
+        return 1
+
+    try:
+        return run_client(
+            directory=directory,
+            host=compile_server if compile_server else url,
+            open_web_browser=open_web_browser,
+            keep_running=not just_compile,
+            build_mode=build_mode,
+            profile=profile,
+        )
+    except KeyboardInterrupt:
+        return 1
+    finally:
+        if compile_server:
+            compile_server.stop()

fastled/compile_server.py

@@ -0,0 +1,87 @@
+from pathlib import Path
+
+from fastled.types import BuildMode, CompileResult, Platform
+
+
+class CompileServer:
+
+    # May throw CompileServerError if auto_start is True.
+    def __init__(
+        self,
+        interactive: bool = False,
+        auto_updates: bool | None = None,
+        mapped_dir: Path | None = None,
+        auto_start: bool = True,
+        container_name: str | None = None,
+        platform: Platform = Platform.WASM,
+    ) -> None:
+        from fastled.compile_server_impl import (  # avoid circular import
+            CompileServerImpl,
+        )
+
+        assert platform == Platform.WASM, "Only WASM platform is supported right now."
+
+        self.impl = CompileServerImpl(
+            container_name=container_name,
+            interactive=interactive,
+            auto_updates=auto_updates,
+            mapped_dir=mapped_dir,
+            auto_start=auto_start,
+        )
+
+    # May throw CompileServerError if server could not be started.
+    def start(self, wait_for_startup=True) -> None:
+        # from fastled.compile_server_impl import CompileServerImpl  # avoid circular import
+        self.impl.start(wait_for_startup=wait_for_startup)
+
+    def web_compile(
+        self,
+        directory: Path | str,
+        build_mode: BuildMode = BuildMode.QUICK,
+        profile: bool = False,
+    ) -> CompileResult:
+        return self.impl.web_compile(
+            directory=directory, build_mode=build_mode, profile=profile
+        )
+
+    def project_init(
+        self, example: str | None = None, outputdir: Path | None = None
+    ) -> None:
+        from fastled.project_init import project_init  # avoid circular import
+
+        project_init(example=example, outputdir=outputdir)
+
+    @property
+    def running(self) -> bool:
+        return self.impl.running
+
+    @property
+    def fastled_src_dir(self) -> Path | None:
+        return self.impl.fastled_src_dir
+
+    def using_fastled_src_dir_volume(self) -> bool:
+        return self.impl.using_fastled_src_dir_volume()
+
+    def port(self) -> int:
+        return self.impl.port()
+
+    def url(self) -> str:
+        return self.impl.url()
+
+    def ping(self) -> bool:
+        return self.impl.ping()
+
+    # by default this is automatically called by the constructor, unless
+    # auto_start is set to False.
+    def wait_for_startup(self, timeout: int = 100) -> bool:
+        """Wait for the server to start up."""
+        return self.impl.wait_for_startup(timeout=timeout)
+
+    def _start(self) -> int:
+        return self.impl._start()
+
+    def stop(self) -> None:
+        return self.impl.stop()
+
+    def process_running(self) -> bool:
+        return self.impl.process_running()