fastled 1.4.18__tar.gz → 1.4.32__tar.gz

fastled-1.4.32/.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "\ud83c\udfaf Auto Debug (Smart File Detection)",
+            "type": "auto-debug",
+            "request": "launch",
+            "map": {
+                "*.ino": "Arduino: Run .ino with FastLED",
+                "*.py": "Python: Current File (UV)"
+            }
+        }
+    ]
+}

fastled-1.4.32/.vscode/tasks.json

@@ -0,0 +1,55 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "type": "shell",
+            "label": "Run FastLED (Debug)",
+            "command": "fastled",
+            "args": [
+                "${file}",
+                "--debug",
+                "--app"
+            ],
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "presentation": {
+                "echo": true,
+                "reveal": "always",
+                "focus": true,
+                "panel": "new",
+                "showReuseMessage": false,
+                "clear": true
+            },
+            "detail": "Run FastLED with debug mode and app visualization",
+            "problemMatcher": []
+        },
+        {
+            "type": "shell",
+            "label": "Run FastLED (Quick)",
+            "command": "fastled",
+            "args": [
+                "${file}",
+                "--background-update"
+            ],
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "group": "build",
+            "presentation": {
+                "echo": true,
+                "reveal": "always",
+                "focus": true,
+                "panel": "new",
+                "showReuseMessage": false,
+                "clear": true
+            },
+            "detail": "Run FastLED with quick background update mode",
+            "problemMatcher": []
+        }
+    ]
+}

{fastled-1.4.18 → fastled-1.4.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.4.18
+Version: 1.4.32
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies

fastled-1.4.32/requirements.docker.txt

@@ -0,0 +1 @@
+fastled-wasm-server>=1.1.37

{fastled-1.4.18 → fastled-1.4.32}/src/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.4.18"
+__version__ = "1.4.32"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

{fastled-1.4.18 → fastled-1.4.32}/src/fastled/app.py

@@ -51,6 +51,16 @@ def main() -> int:
     from fastled.select_sketch_directory import select_sketch_directory
 
     args = parse_args()
+
+    # 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
     has_server = args.server
     update: bool = args.update

{fastled-1.4.18 → fastled-1.4.32}/src/fastled/args.py

@@ -16,6 +16,7 @@ class Args:
     app: bool  # New flag to trigger Playwright browser with browser download if needed
     auto_update: bool | None
     update: bool
+    background_update: bool
     localhost: bool
     build: bool
     server: bool
@@ -25,6 +26,9 @@ class Args:
     release: bool
     ram_disk_size: str  # suffixed liked "25mb" or "1gb"
     clear = False  # Force the last running container to be removed. Useful for benchmarking.
+    install: bool = False  # Install FastLED development environment
+    dry_run: bool = False  # Dry run mode for testing
+    no_interactive: bool = False  # Non-interactive mode
 
     @staticmethod
     def from_namespace(args: argparse.Namespace) -> "Args":
@@ -57,6 +61,9 @@ class Args:
             args.no_auto_updates, bool | None
         ), f"expected bool | None, got {type(args.no_auto_updates)}"
         assert isinstance(args.update, bool), f"expected bool, got {type(args.update)}"
+        assert isinstance(
+            args.background_update, bool
+        ), f"expected bool, got {type(args.background_update)}"
         assert isinstance(
             args.localhost, bool
         ), f"expected bool, got {type(args.localhost)}"
@@ -68,6 +75,15 @@ class Args:
         assert isinstance(
             args.release, bool
         ), f"expected bool, got {type(args.release)}"
+        assert isinstance(
+            args.install, bool
+        ), f"expected bool, got {type(args.install)}"
+        assert isinstance(
+            args.dry_run, bool
+        ), f"expected bool, got {type(args.dry_run)}"
+        assert isinstance(
+            args.no_interactive, bool
+        ), f"expected bool, got {type(args.no_interactive)}"
 
         init: bool | str = False
         if args.init is None:
@@ -88,6 +104,7 @@ class Args:
             app=args.app,
             auto_update=not args.no_auto_updates,
             update=args.update,
+            background_update=args.background_update,
             localhost=args.localhost,
             build=args.build,
             server=args.server,
@@ -96,4 +113,7 @@ class Args:
             quick=args.quick,
             release=args.release,
             ram_disk_size=args.ram_disk_size,
+            install=args.install,
+            dry_run=args.dry_run,
+            no_interactive=args.no_interactive,
         )

{fastled-1.4.18 → fastled-1.4.32}/src/fastled/client_server.py

@@ -100,7 +100,7 @@ def _run_web_compiler(
 
     # Guard: libfastled compilation requires volume source mapping
     if not allow_libcompile:
-        print("⚠️  libfastled compilation disabled: not running in FastLED repository")
+        print("⚠️  libfastled compilation disabled.")
 
     start = time.time()
     web_result = web_compile(
@@ -243,14 +243,35 @@ def _try_make_compile_server(
         return None
 
 
-def _is_local_host(host: str) -> bool:
+def _background_update_docker_image() -> None:
+    """Perform docker image update in the background."""
+    try:
+        print("\n🔄 Starting background update of docker image...")
+        docker_manager = DockerManager()
+        updated = docker_manager.validate_or_download_image(
+            image_name=IMAGE_NAME, tag="latest", upgrade=True
+        )
+        if updated:
+            print("✅ Background docker image update completed successfully.")
+        else:
+            print("ℹ️  Docker image was already up to date.")
+    except KeyboardInterrupt:
+        print("⚠️  Background docker image update interrupted by user.")
+        import _thread
+
+        _thread.interrupt_main()
+    except Exception as e:
+        print(f"⚠️  Background docker image update failed: {e}")
+
+
+def _is_local_host(url: str) -> bool:
     return (
-        host.startswith("http://localhost")
-        or host.startswith("http://127.0.0.1")
-        or host.startswith("http://0.0.0.0")
-        or host.startswith("http://[::]")
-        or host.startswith("http://[::1]")
-        or host.startswith("http://[::ffff:127.0.0.1]")
+        url.startswith("http://localhost")
+        or url.startswith("http://127.0.0.1")
+        or url.startswith("http://0.0.0.0")
+        or url.startswith("http://[::]")
+        or url.startswith("http://[::1]")
+        or url.startswith("http://[::ffff:127.0.0.1]")
     )
 
 
@@ -268,6 +289,7 @@ def run_client(
     clear: bool = False,
     no_platformio: bool = False,
     app: bool = False,  # Use app-like browser experience
+    background_update: bool = False,
 ) -> int:
     has_checked_newer_version_yet = False
     compile_server: CompileServer | None = None
@@ -426,9 +448,20 @@ def run_client(
                     )
                     if has_update:
                         print(f"\n🔄 {message}")
-                        print(
-                            "Run with `fastled -u` to update the docker image to the latest version."
-                        )
+                        if background_update:
+                            # Start background update in a separate thread
+                            update_thread = threading.Thread(
+                                target=_background_update_docker_image, daemon=True
+                            )
+                            update_thread.start()
+                            background_update = False
+                        else:
+                            print(
+                                "Run with `fastled -u` to update the docker image to the latest version."
+                            )
+                            print(
+                                "Or use `--background-update` to update automatically in the background after compilation."
+                            )
                 except Exception as e:
                     # Don't let Docker check failures interrupt the main flow
                     warnings.warn(f"Failed to check for Docker image updates: {e}")
@@ -461,9 +494,6 @@ def run_client(
                     print(f"\nChanges detected in FastLED source code: {changed_files}")
                     print("Press space bar to trigger compile.")
 
-                    # Re-evaluate libcompile capability when source code changes
-                    allow_libcompile = True
-
                     while True:
                         space_bar_pressed = SpaceBarWatcher.watch_space_bar_pressed(
                             timeout=1.0
@@ -477,6 +507,8 @@ def run_client(
                             print(
                                 f"Changes detected in {file_changes}\nHit the space bar to trigger compile."
                             )
+                            # Re-evaluate libcompile capability when source code changes
+                            allow_libcompile = True
 
                         if space_bar_pressed or sketch_files_changed:
                             if space_bar_pressed:
@@ -488,7 +520,9 @@ def run_client(
                             last_compiled_result = compile_function(
                                 last_hash_value=None, allow_libcompile=allow_libcompile
                             )
-                            allow_libcompile = False
+                            allow_libcompile = (
+                                allow_libcompile and not last_compiled_result.success
+                            )
                             print("Finished recompile.")
                             # Drain the space bar queue
                             SpaceBarWatcher.watch_space_bar_pressed()
@@ -513,6 +547,7 @@ def run_client_server(args: Args) -> 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)
+    background_update = bool(args.background_update)
     localhost = bool(args.localhost)
     directory = args.directory if args.directory else Path(".")
     just_compile = bool(args.just_compile)
@@ -585,6 +620,7 @@ def run_client_server(args: Args) -> int:
             clear=args.clear,
             no_platformio=no_platformio,
             app=app,
+            background_update=background_update,
         )
     except KeyboardInterrupt:
         return 1

{fastled-1.4.18 → fastled-1.4.32}/src/fastled/filewatcher.py

@@ -122,6 +122,9 @@ class FileChangedNotifier(threading.Thread):
                 time.sleep(0.1)
         except KeyboardInterrupt:
             print("File watcher stopped by user.")
+            import _thread
+
+            _thread.interrupt_main()
         finally:
             self.stop()
 

fastled-1.4.32/src/fastled/install/__init__.py

@@ -0,0 +1 @@
+"""FastLED install module."""

fastled-1.4.32/src/fastled/install/examples_manager.py

@@ -0,0 +1,62 @@
+"""Examples installation manager using FastLED's built-in --project-init command."""
+
+import subprocess
+
+
+def install_fastled_examples_via_project_init(
+    force: bool = False, no_interactive: bool = False
+) -> bool:
+    """
+    Install FastLED examples using built-in --project-init command.
+
+    Args:
+        force: If True, install without prompting
+        no_interactive: If True, skip prompting and return False
+
+    Returns:
+        True if installation successful, False otherwise
+    """
+    if not force:
+        if no_interactive:
+            print("⚠️  No existing Arduino content found.")
+            print("    In non-interactive mode, skipping examples installation.")
+            print("    Run 'fastled --project-init' manually to install examples.")
+            return False
+
+        print("No existing Arduino content found.")
+        answer = (
+            input("Would you like to install FastLED examples? [y/n] ").strip().lower()
+        )
+        if answer not in ["y", "yes"]:
+            print("Skipping FastLED examples installation.")
+            return False
+
+    print("📦 Installing FastLED examples using project initialization...")
+
+    try:
+        # Use FastLED's built-in project initialization
+        subprocess.run(
+            ["fastled", "--project-init"],
+            check=True,
+            capture_output=True,
+            text=True,
+            cwd=".",
+        )
+
+        print("✅ FastLED project initialized successfully!")
+        print("📁 Examples and project structure created")
+        print("🚀 Quick start: Check for generated .ino files and press F5 to debug")
+
+        return True
+
+    except subprocess.CalledProcessError as e:
+        print(f"⚠️  Warning: Failed to initialize FastLED project: {e}")
+        if e.stderr:
+            print(f"Error details: {e.stderr}")
+        print("You can manually run: fastled --project-init")
+        return False
+    except FileNotFoundError:
+        print("⚠️  Warning: FastLED package not found. Please install it first:")
+        print("    pip install fastled")
+        print("Then run: fastled --project-init")
+        return False

fastled-1.4.32/src/fastled/install/extension_manager.py

@@ -0,0 +1,113 @@
+"""Auto Debug extension installation manager."""
+
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from urllib.request import urlretrieve
+
+
+def download_auto_debug_extension() -> Path | None:
+    """
+    Download the Auto Debug extension .vsix file from GitHub.
+
+    Returns:
+        Path to downloaded .vsix file, or None if download fails
+    """
+    # URL for the Auto Debug extension
+    extension_url = "https://github.com/zackees/vscode-auto-debug/releases/latest/download/auto-debug.vsix"
+
+    try:
+        # Create temporary directory
+        temp_dir = Path(tempfile.mkdtemp())
+        vsix_path = temp_dir / "auto-debug.vsix"
+
+        print("📥 Downloading Auto Debug extension...")
+
+        # Download the file
+        urlretrieve(extension_url, vsix_path)
+
+        if vsix_path.exists() and vsix_path.stat().st_size > 0:
+            print("✅ Extension downloaded successfully")
+            return vsix_path
+        else:
+            print("❌ Failed to download extension")
+            return None
+
+    except Exception as e:
+        print(f"❌ Error downloading extension: {e}")
+        return None
+
+
+def install_vscode_extensions(extension_path: Path) -> bool:
+    """
+    Install extension in VSCode or Cursor.
+
+    Args:
+        extension_path: Path to .vsix file
+
+    Returns:
+        True if installation successful, False otherwise
+    """
+    # Try VSCode first
+    if shutil.which("code"):
+        ide_command = "code"
+        ide_name = "VSCode"
+    elif shutil.which("cursor"):
+        ide_command = "cursor"
+        ide_name = "Cursor"
+    else:
+        print("❌ No supported IDE found (VSCode or Cursor)")
+        return False
+
+    try:
+        print(f"📦 Installing extension in {ide_name}...")
+
+        # Install the extension
+        subprocess.run(
+            [ide_command, "--install-extension", str(extension_path)],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        print(f"✅ Auto Debug extension installed in {ide_name}")
+        return True
+
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to install extension: {e}")
+        if e.stderr:
+            print(f"Error details: {e.stderr}")
+        return False
+    finally:
+        # Clean up temporary file
+        if extension_path.exists():
+            try:
+                extension_path.unlink()
+                extension_path.parent.rmdir()
+            except Exception:
+                pass
+
+
+def install_auto_debug_extension(dry_run: bool = False) -> bool:
+    """
+    Main function to download and install Auto Debug extension.
+
+    Args:
+        dry_run: If True, simulate installation without actually installing
+
+    Returns:
+        True if installation successful, False otherwise
+    """
+    if dry_run:
+        print("[DRY-RUN]: Would download and install Auto Debug extension")
+        print("[DRY-RUN]: NO PLUGIN INSTALLED")
+        return True
+
+    # Download extension
+    vsix_path = download_auto_debug_extension()
+    if not vsix_path:
+        return False
+
+    # Install extension
+    return install_vscode_extensions(vsix_path)

fastled-1.4.32/src/fastled/install/main.py

@@ -0,0 +1,156 @@
+"""Main installation orchestrator for FastLED --install feature."""
+
+import sys
+
+from .examples_manager import install_fastled_examples_via_project_init
+from .extension_manager import install_auto_debug_extension
+from .project_detection import (
+    check_existing_arduino_content,
+    detect_fastled_project,
+    is_fastled_repository,
+    validate_vscode_project,
+)
+from .vscode_config import (
+    generate_fastled_tasks,
+    update_launch_json_for_arduino,
+    update_vscode_settings_for_fastled,
+)
+
+
+def fastled_install(dry_run: bool = False, no_interactive: bool = False) -> bool:
+    """
+    Main installation function with dry-run support.
+
+    Args:
+        dry_run: If True, simulate installation without making changes
+        no_interactive: If True, fail instead of prompting for input
+
+    Returns:
+        True if installation successful, False otherwise
+    """
+    try:
+        print("🚀 Starting FastLED installation...")
+
+        # 1. Validate VSCode project or offer alternatives
+        if not validate_vscode_project(no_interactive):
+            return False
+
+        # 2. Detect project type
+        is_fastled_project = detect_fastled_project()
+        is_repository = is_fastled_repository()
+
+        if is_fastled_project:
+            if is_repository:
+                print(
+                    "✅ Detected FastLED repository - will configure full development environment"
+                )
+            else:
+                print(
+                    "✅ Detected external FastLED project - will configure Arduino environment"
+                )
+        else:
+            print(
+                "✅ Detected standard project - will configure basic Arduino environment"
+            )
+
+        # 3. Auto Debug extension (with prompt)
+        if not dry_run and not no_interactive:
+            answer = (
+                input(
+                    "\nWould you like to install the plugin for FastLED (auto-debug)? [y/n] "
+                )
+                .strip()
+                .lower()
+            )
+        elif no_interactive:
+            print(
+                "\n⚠️  Skipping Auto Debug extension installation in non-interactive mode"
+            )
+            answer = "no"
+        else:
+            answer = "yes"
+            print("\n[DRY-RUN]: Simulating Auto Debug extension installation...")
+
+        if answer in ["y", "yes"]:
+            if not install_auto_debug_extension(dry_run):
+                print(
+                    "⚠️  Warning: Auto Debug extension installation failed, continuing..."
+                )
+
+        # 4. Configure VSCode files
+        print("\n📝 Configuring VSCode files...")
+        update_launch_json_for_arduino()
+        generate_fastled_tasks()
+
+        # 5. Examples installation (conditional)
+        if not check_existing_arduino_content():
+            if no_interactive:
+                print(
+                    "⚠️  No Arduino content found. In non-interactive mode, skipping examples installation."
+                )
+                print("    Run 'fastled --project-init' manually to install examples.")
+            else:
+                install_fastled_examples_via_project_init(no_interactive=no_interactive)
+        else:
+            print(
+                "✅ Existing Arduino content detected, skipping examples installation"
+            )
+
+        # 6. Full development setup (repository only)
+        if is_fastled_project:
+            if is_repository:
+                print("\n🔧 Setting up FastLED development environment...")
+                update_vscode_settings_for_fastled()
+            else:
+                print(
+                    "\n⚠️  Skipping clangd settings - not in FastLED repository (protects your environment)"
+                )
+
+        # 7. Post-installation auto-execution
+        if not dry_run:
+            auto_execute_fastled()
+        else:
+            print("\n[DRY-RUN]: Skipping auto-execution")
+
+        print("\n✅ FastLED installation completed successfully!")
+        return True
+
+    except Exception as e:
+        print(f"\n❌ Installation failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+def auto_execute_fastled() -> None:
+    """Auto-launch fastled after successful installation."""
+    if check_existing_arduino_content():
+        print("\n🚀 Auto-launching FastLED...")
+
+        # Import the main function to avoid circular imports
+        from fastled.app import main
+
+        # Filter out --install and --dry-run from sys.argv
+        original_argv = sys.argv.copy()
+        filtered_argv = [
+            arg for arg in sys.argv if arg not in ["--install", "--dry-run"]
+        ]
+
+        # If no directory specified, add current directory
+        if len(filtered_argv) == 1:  # Only the command name
+            filtered_argv.append(".")
+
+        # Replace sys.argv temporarily
+        sys.argv = filtered_argv
+
+        try:
+            # Call main directly
+            main()
+        finally:
+            # Restore original argv
+            sys.argv = original_argv
+    else:
+        print(
+            "\n💡 No Arduino content found. Create some .ino files and run 'fastled' to compile!"
+        )