fastled 1.3.28__py3-none-any.whl → 1.3.29__py3-none-any.whl

fastled/__version__.py

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

fastled/app.py

@@ -1,177 +1,177 @@
-"""
-Uses the latest wasm compiler image to compile the FastLED sketch.
-"""
-
-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.filewatcher import file_watcher_set
-from fastled.parse_args import Args, parse_args
-from fastled.sketch import find_sketch_directories, looks_like_fastled_repo
-
-
-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
-    if interactive and mapped_dir is None:
-        print("Select a sketch when you enter interactive mode.")
-        return 1
-    compile_server = CompileServer(
-        interactive=interactive,
-        auto_updates=auto_update,
-        mapped_dir=mapped_dir,
-        auto_start=True,
-        remove_previous=args.clear,
-    )
-
-    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:
-    from fastled import __version__
-    from fastled.select_sketch_directory import select_sketch_directory
-
-    args = parse_args()
-    interactive: bool = args.interactive
-    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
-    cwd_looks_like_fastled_repo = looks_like_fastled_repo()
-
-    # now it is safe to print out the version
-    print(f"FastLED version: {__version__}")
-
-    # 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
-                )
-                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.stop()
-        print("Finished updating.")
-        return 0
-
-    if build:
-        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,
-        )
-
-        server.start(wait_for_startup=False)
-
-        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
-            print(f"Built Docker image: {server.name}")
-            if not directory:
-                if not directory:
-                    print("No directory specified")
-                server.stop()
-                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 _:
-                while True:
-                    time.sleep(0.2)  # wait for user to exit
-        except KeyboardInterrupt:
-            print("\nExiting from client...")
-            server.stop()
-            return 1
-
-    if has_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__":
-    # Note that the entry point for the exe is in cli.py
-    try:
-        # 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...")
-        sys.exit(1)
-    except Exception as e:
-        print(f"Error: {e}")
-        sys.exit(1)
+"""
+Uses the latest wasm compiler image to compile the FastLED sketch.
+"""
+
+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.filewatcher import file_watcher_set
+from fastled.parse_args import Args, parse_args
+from fastled.sketch import find_sketch_directories, looks_like_fastled_repo
+
+
+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
+    if interactive and mapped_dir is None:
+        print("Select a sketch when you enter interactive mode.")
+        return 1
+    compile_server = CompileServer(
+        interactive=interactive,
+        auto_updates=auto_update,
+        mapped_dir=mapped_dir,
+        auto_start=True,
+        remove_previous=args.clear,
+    )
+
+    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:
+    from fastled import __version__
+    from fastled.select_sketch_directory import select_sketch_directory
+
+    args = parse_args()
+    interactive: bool = args.interactive
+    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
+    cwd_looks_like_fastled_repo = looks_like_fastled_repo()
+
+    # now it is safe to print out the version
+    print(f"FastLED version: {__version__}")
+
+    # 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
+                )
+                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.stop()
+        print("Finished updating.")
+        return 0
+
+    if build:
+        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,
+        )
+
+        server.start(wait_for_startup=False)
+
+        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
+            print(f"Built Docker image: {server.name}")
+            if not directory:
+                if not directory:
+                    print("No directory specified")
+                server.stop()
+                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 _:
+                while True:
+                    time.sleep(0.2)  # wait for user to exit
+        except KeyboardInterrupt:
+            print("\nExiting from client...")
+            server.stop()
+            return 1
+
+    if has_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__":
+    # Note that the entry point for the exe is in cli.py
+    try:
+        # 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...")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)

fastled/open_browser.py

@@ -1,137 +1,137 @@
-import atexit
-import random
-import sys
-import time
-import weakref
-from multiprocessing import Process
-from pathlib import Path
-
-from fastled.server_flask import run_flask_in_thread
-
-DEFAULT_PORT = 8089  # different than live version.
-PYTHON_EXE = sys.executable
-
-# Use a weak reference set to track processes without preventing garbage collection
-_WEAK_CLEANUP_SET = weakref.WeakSet()
-
-
-def add_cleanup(proc: Process) -> None:
-    """Add a process to the cleanup list using weak references"""
-    _WEAK_CLEANUP_SET.add(proc)
-
-    # Register a cleanup function that checks if the process is still alive
-    def cleanup_if_alive():
-        if proc.is_alive():
-            try:
-                proc.terminate()
-                proc.join(timeout=1.0)
-                if proc.is_alive():
-                    proc.kill()
-            except Exception:
-                pass
-
-    atexit.register(cleanup_if_alive)
-
-
-def is_port_free(port: int) -> bool:
-    """Check if a port is free"""
-    import httpx
-
-    try:
-        response = httpx.get(f"http://localhost:{port}", timeout=1)
-        response.raise_for_status()
-        return False
-    except (httpx.HTTPError, httpx.ConnectError):
-        return True
-
-
-def find_free_port(start_port: int) -> int:
-    """Find a free port starting at start_port"""
-    for port in range(start_port, start_port + 100, 2):
-        if is_port_free(port):
-            print(f"Found free port: {port}")
-            return port
-        else:
-            print(f"Port {port} is in use, finding next")
-    raise ValueError("Could not find a free port")
-
-
-def wait_for_server(port: int, timeout: int = 10) -> None:
-    """Wait for the server to start."""
-    from httpx import get
-
-    future_time = time.time() + timeout
-    while future_time > time.time():
-        try:
-            url = f"http://localhost:{port}"
-            # print(f"Waiting for server to start at {url}")
-            response = get(url, timeout=1)
-            if response.status_code == 200:
-                return
-        except Exception:
-            continue
-    raise TimeoutError("Could not connect to server")
-
-
-def spawn_http_server(
-    fastled_js: Path,
-    compile_server_port: int,
-    port: int | None = None,
-    open_browser: bool = True,
-) -> Process:
-
-    if port is not None and not is_port_free(port):
-        raise ValueError(f"Port {port} was specified but in use")
-    if port is None:
-        offset = random.randint(0, 100)
-        port = find_free_port(DEFAULT_PORT + offset)
-
-    # port: int,
-    # cwd: Path,
-    # compile_server_port: int,
-    # certfile: Path | None = None,
-    # keyfile: Path | None = None,
-
-    proc = Process(
-        target=run_flask_in_thread,
-        args=(port, fastled_js, compile_server_port),
-        daemon=True,
-    )
-    add_cleanup(proc)
-    proc.start()
-
-    # Add to cleanup set with weak reference
-    add_cleanup(proc)
-
-    wait_for_server(port)
-    if open_browser:
-        print(f"Opening browser to http://localhost:{port}")
-        import webbrowser
-
-        webbrowser.open(
-            url=f"http://localhost:{port}",
-            new=1,
-            autoraise=True,
-        )
-    return proc
-
-
-if __name__ == "__main__":
-    import argparse
-
-    parser = argparse.ArgumentParser(
-        description="Open a browser to the fastled_js directory"
-    )
-    parser.add_argument(
-        "fastled_js", type=Path, help="Path to the fastled_js directory"
-    )
-    parser.add_argument(
-        "--port",
-        type=int,
-        default=DEFAULT_PORT,
-        help=f"Port to run the server on (default: {DEFAULT_PORT})",
-    )
-    args = parser.parse_args()
-
-    proc = spawn_http_server(args.fastled_js, args.port, open_browser=True)
-    proc.join()
+import atexit
+import random
+import sys
+import time
+import weakref
+from multiprocessing import Process
+from pathlib import Path
+
+from fastled.server_flask import run_flask_in_thread
+
+DEFAULT_PORT = 8089  # different than live version.
+PYTHON_EXE = sys.executable
+
+# Use a weak reference set to track processes without preventing garbage collection
+_WEAK_CLEANUP_SET = weakref.WeakSet()
+
+
+def add_cleanup(proc: Process) -> None:
+    """Add a process to the cleanup list using weak references"""
+    _WEAK_CLEANUP_SET.add(proc)
+
+    # Register a cleanup function that checks if the process is still alive
+    def cleanup_if_alive():
+        if proc.is_alive():
+            try:
+                proc.terminate()
+                proc.join(timeout=1.0)
+                if proc.is_alive():
+                    proc.kill()
+            except Exception:
+                pass
+
+    atexit.register(cleanup_if_alive)
+
+
+def is_port_free(port: int) -> bool:
+    """Check if a port is free"""
+    import httpx
+
+    try:
+        response = httpx.get(f"http://localhost:{port}", timeout=1)
+        response.raise_for_status()
+        return False
+    except (httpx.HTTPError, httpx.ConnectError):
+        return True
+
+
+def find_free_port(start_port: int) -> int:
+    """Find a free port starting at start_port"""
+    for port in range(start_port, start_port + 100, 2):
+        if is_port_free(port):
+            print(f"Found free port: {port}")
+            return port
+        else:
+            print(f"Port {port} is in use, finding next")
+    raise ValueError("Could not find a free port")
+
+
+def wait_for_server(port: int, timeout: int = 10) -> None:
+    """Wait for the server to start."""
+    from httpx import get
+
+    future_time = time.time() + timeout
+    while future_time > time.time():
+        try:
+            url = f"http://localhost:{port}"
+            # print(f"Waiting for server to start at {url}")
+            response = get(url, timeout=1)
+            if response.status_code == 200:
+                return
+        except Exception:
+            continue
+    raise TimeoutError("Could not connect to server")
+
+
+def spawn_http_server(
+    fastled_js: Path,
+    compile_server_port: int,
+    port: int | None = None,
+    open_browser: bool = True,
+) -> Process:
+
+    if port is not None and not is_port_free(port):
+        raise ValueError(f"Port {port} was specified but in use")
+    if port is None:
+        offset = random.randint(0, 100)
+        port = find_free_port(DEFAULT_PORT + offset)
+
+    # port: int,
+    # cwd: Path,
+    # compile_server_port: int,
+    # certfile: Path | None = None,
+    # keyfile: Path | None = None,
+
+    proc = Process(
+        target=run_flask_in_thread,
+        args=(port, fastled_js, compile_server_port),
+        daemon=True,
+    )
+    add_cleanup(proc)
+    proc.start()
+
+    # Add to cleanup set with weak reference
+    add_cleanup(proc)
+
+    wait_for_server(port)
+    if open_browser:
+        print(f"Opening browser to http://localhost:{port}")
+        import webbrowser
+
+        webbrowser.open(
+            url=f"http://localhost:{port}",
+            new=1,
+            autoraise=True,
+        )
+    return proc
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Open a browser to the fastled_js directory"
+    )
+    parser.add_argument(
+        "fastled_js", type=Path, help="Path to the fastled_js directory"
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=DEFAULT_PORT,
+        help=f"Port to run the server on (default: {DEFAULT_PORT})",
+    )
+    args = parser.parse_args()
+
+    proc = spawn_http_server(args.fastled_js, args.port, open_browser=True)
+    proc.join()