fastled 1.4.31__py3-none-any.whl → 1.4.32__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.4.31"
+__version__ = "1.4.32"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

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/args.py

@@ -26,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":
@@ -72,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:
@@ -101,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/install/__init__.py

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

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/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/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!"
+        )

fastled/install/project_detection.py

@@ -0,0 +1,167 @@
+"""Project detection logic for FastLED installation."""
+
+import json
+import shutil
+from pathlib import Path
+
+
+def validate_vscode_project(no_interactive: bool = False) -> bool:
+    """
+    Validate if current directory has a VSCode project.
+    If not found, search parent directories, offer alternatives.
+    Returns True if a VSCode project is found or created.
+
+    Args:
+        no_interactive: If True, fail instead of prompting for input
+    """
+    current_dir = Path.cwd()
+
+    # Check current directory
+    if (current_dir / ".vscode").exists():
+        return True
+
+    # Search parent directories
+    parent_path = find_vscode_project_upward()
+    if parent_path:
+        if no_interactive:
+            print("❌ No .vscode directory found in current directory.")
+            print(f"   Found .vscode in parent: {parent_path}")
+            print("   In non-interactive mode, cannot change directory.")
+            print(f"   Please cd to {parent_path} and run the command again.")
+            return False
+        answer = (
+            input(f"Found a .vscode project in {parent_path}/\nInstall there? [y/n] ")
+            .strip()
+            .lower()
+        )
+        if answer in ["y", "yes"]:
+            import os
+
+            os.chdir(parent_path)
+            return True
+
+    # Check if IDE is available
+    if not (shutil.which("code") or shutil.which("cursor")):
+        print(
+            "No supported IDE found (VSCode or Cursor). Please install VSCode or Cursor first."
+        )
+        return False
+
+    # Offer to create new project
+    if no_interactive:
+        print(
+            "❌ No .vscode directory found in current directory or parent directories."
+        )
+        print("   In non-interactive mode, cannot create new project.")
+        print("   Please create a .vscode directory or run without --no-interactive.")
+        return False
+
+    print("No .vscode directory found in current directory or parent directories.")
+    answer = (
+        input(
+            "Would you like to generate a VSCode project with FastLED configuration? [y/n] "
+        )
+        .strip()
+        .lower()
+    )
+    if answer in ["y", "yes"]:
+        return generate_vscode_project()
+
+    return False
+
+
+def find_vscode_project_upward(max_levels: int = 5) -> Path | None:
+    """Search parent directories for .vscode folder."""
+    current = Path.cwd()
+
+    for _ in range(max_levels):
+        parent = current.parent
+        if parent == current:  # Reached root
+            break
+        current = parent
+        if (current / ".vscode").exists():
+            return current
+
+    return None
+
+
+def generate_vscode_project() -> bool:
+    """Create a new .vscode directory structure."""
+    vscode_dir = Path.cwd() / ".vscode"
+    vscode_dir.mkdir(exist_ok=True)
+    print(f"✅ Created .vscode directory at {vscode_dir}")
+    return True
+
+
+def detect_fastled_project() -> bool:
+    """Check if library.json contains FastLED."""
+    library_json = Path.cwd() / "library.json"
+    if not library_json.exists():
+        return False
+
+    try:
+        with open(library_json, "r") as f:
+            data = json.load(f)
+            return data.get("name") == "FastLED"
+    except (json.JSONDecodeError, KeyError):
+        return False
+
+
+def is_fastled_repository() -> bool:
+    """
+    🚨 CRITICAL: Detect actual FastLED repository.
+    Strict verification of multiple markers.
+    """
+    cwd = Path.cwd()
+
+    # Required files and directories for FastLED repository
+    required_markers = [
+        cwd / "src" / "FastLED.h",
+        cwd / "examples" / "Blink" / "Blink.ino",
+        cwd / "ci" / "ci-compile.py",
+        cwd / "src" / "platforms",
+        cwd / "library.json",
+    ]
+
+    # Check all markers exist
+    if not all(marker.exists() for marker in required_markers):
+        return False
+
+    # Verify library.json has correct content
+    try:
+        with open(cwd / "library.json", "r") as f:
+            data = json.load(f)
+            if data.get("name") != "FastLED":
+                return False
+            repo_url = data.get("repository", {}).get("url", "")
+            if "FastLED/FastLED" not in repo_url:
+                return False
+    except (json.JSONDecodeError, KeyError, FileNotFoundError):
+        return False
+
+    # Check for test files pattern
+    test_dir = cwd / "tests"
+    if test_dir.exists() and test_dir.is_dir():
+        test_files = list(test_dir.glob("test_*.cpp"))
+        if not test_files:
+            return False
+    else:
+        return False
+
+    return True
+
+
+def check_existing_arduino_content() -> bool:
+    """Check for .ino files OR examples/ folder."""
+    cwd = Path.cwd()
+
+    # Check for any .ino files
+    ino_files = list(cwd.rglob("*.ino"))
+    if ino_files:
+        return True
+
+    # Check for examples folder
+    if (cwd / "examples").exists():
+        return True
+
+    return False