fastled 1.4.30__py3-none-any.whl → 1.4.32__py3-none-any.whl

fastled/install/test_install.py

@@ -0,0 +1,373 @@
+"""Comprehensive test suite for FastLED install feature."""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from fastled.install.main import auto_execute_fastled, fastled_install
+from fastled.install.project_detection import (
+    check_existing_arduino_content,
+)
+from fastled.install.vscode_config import (
+    generate_fastled_tasks,
+    update_launch_json_for_arduino,
+    update_vscode_settings_for_fastled,
+)
+
+
+class TestFastLEDInstall(unittest.TestCase):
+    """Test FastLED installation functionality."""
+
+    def setUp(self):
+        """Set up test environment."""
+        self.test_dir = tempfile.mkdtemp()
+        self.original_cwd = os.getcwd()
+        os.chdir(self.test_dir)
+
+    def tearDown(self):
+        """Clean up test environment."""
+        os.chdir(self.original_cwd)
+        shutil.rmtree(self.test_dir)
+
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_dry_run_basic_project(self, mock_input, mock_which):
+        """Test 1: Dry-run in basic project."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.return_value = "y"
+        os.makedirs(".vscode")
+
+        # Run
+        result = fastled_install(dry_run=True, no_interactive=True)
+
+        # Verify
+        self.assertTrue(result)
+        self.assertTrue(Path(".vscode/launch.json").exists())
+        self.assertTrue(Path(".vscode/tasks.json").exists())
+
+    @patch("fastled.install.project_detection.is_fastled_repository")
+    @patch("fastled.install.project_detection.detect_fastled_project")
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_dry_run_fastled_external(
+        self, mock_input, mock_which, mock_detect, mock_repo
+    ):
+        """Test 2: Dry-run in external FastLED project."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.return_value = "y"
+        mock_detect.return_value = True
+        mock_repo.return_value = False
+        os.makedirs(".vscode")
+
+        # Create library.json
+        with open("library.json", "w") as f:
+            json.dump({"name": "FastLED"}, f)
+
+        # Run
+        result = fastled_install(dry_run=True, no_interactive=True)
+
+        # Verify
+        self.assertTrue(result)
+        self.assertFalse(Path(".vscode/settings.json").exists())  # No clangd settings
+
+    @patch("fastled.install.project_detection.is_fastled_repository")
+    @patch("fastled.install.project_detection.detect_fastled_project")
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_dry_run_fastled_repository(
+        self, mock_input, mock_which, mock_detect, mock_repo
+    ):
+        """Test 3: Dry-run in actual FastLED repository."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.return_value = "y"
+        mock_detect.return_value = True
+        mock_repo.return_value = True
+        os.makedirs(".vscode")
+
+        # Run
+        result = fastled_install(dry_run=True, no_interactive=True)
+
+        # Verify
+        self.assertTrue(result)
+        self.assertTrue(Path(".vscode/settings.json").exists())  # Has clangd settings
+
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_existing_vscode_project(self, mock_input, mock_which):
+        """Test 4: Merge with existing .vscode configs."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.return_value = "y"
+        os.makedirs(".vscode")
+
+        # Create existing launch.json
+        existing_config = {
+            "version": "0.2.0",
+            "configurations": [{"name": "Existing", "type": "node"}],
+        }
+        with open(".vscode/launch.json", "w") as f:
+            json.dump(existing_config, f)
+
+        # Run
+        result = fastled_install(dry_run=True, no_interactive=True)
+
+        # Verify
+        self.assertTrue(result)
+        with open(".vscode/launch.json") as f:
+            data = json.load(f)
+            self.assertEqual(len(data["configurations"]), 2)
+            self.assertEqual(
+                data["configurations"][0]["name"],
+                "🎯 Auto Debug (Smart File Detection)",
+            )
+
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_parent_directory_detection(self, mock_input, mock_which):
+        """Test 5: Find .vscode in parent directories."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        parent_dir = Path(self.test_dir)
+        child_dir = parent_dir / "child" / "grandchild"
+        child_dir.mkdir(parents=True)
+        (parent_dir / ".vscode").mkdir()
+        os.chdir(child_dir)
+
+        # Test non-interactive mode - should fail
+        result = fastled_install(dry_run=True, no_interactive=True)
+        self.assertFalse(result)  # Should fail in non-interactive
+
+        # Test interactive mode
+        mock_input.side_effect = ["y", "y"]  # Yes to parent, yes to extension
+        result = fastled_install(dry_run=True, no_interactive=False)
+
+        # Verify - we should be in parent directory now
+        self.assertTrue(result)
+        self.assertEqual(Path.cwd(), parent_dir)
+
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_project_generation(self, mock_input, mock_which):
+        """Test 6: Generate new VSCode project."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+
+        # Test non-interactive mode - should fail
+        result = fastled_install(dry_run=True, no_interactive=True)
+        self.assertFalse(result)  # Should fail without .vscode
+
+        # Test interactive mode
+        mock_input.side_effect = ["y", "y"]  # Yes to generate, yes to extension
+        result = fastled_install(dry_run=True, no_interactive=False)
+
+        # Verify
+        self.assertTrue(result)
+        self.assertTrue(Path(".vscode").exists())
+        self.assertTrue(Path(".vscode/launch.json").exists())
+        self.assertTrue(Path(".vscode/tasks.json").exists())
+
+    def test_arduino_content_detection(self):
+        """Test 7: Detect existing .ino files."""
+        # Create .ino file
+        with open("test.ino", "w") as f:
+            f.write("void setup() {}")
+
+        # Test detection
+        self.assertTrue(check_existing_arduino_content())
+
+        # Remove and test examples folder
+        os.unlink("test.ino")
+        os.makedirs("examples")
+        self.assertTrue(check_existing_arduino_content())
+
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_tasks_json_merging(self, mock_input, mock_which):
+        """Test 8: Merge FastLED tasks with existing."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.return_value = "y"
+        os.makedirs(".vscode")
+
+        # Create existing tasks.json
+        existing_tasks = {
+            "version": "2.0.0",
+            "tasks": [{"label": "Existing Task", "command": "echo"}],
+        }
+        with open(".vscode/tasks.json", "w") as f:
+            json.dump(existing_tasks, f)
+
+        # Run
+        generate_fastled_tasks()
+
+        # Verify
+        with open(".vscode/tasks.json") as f:
+            data = json.load(f)
+            self.assertEqual(len(data["tasks"]), 3)  # 1 existing + 2 FastLED
+            labels = [task["label"] for task in data["tasks"]]
+            self.assertIn("Run FastLED (Debug)", labels)
+            self.assertIn("Run FastLED (Quick)", labels)
+
+    def test_launch_json_updates(self):
+        """Test 9: Update launch.json configurations."""
+        # Setup
+        os.makedirs(".vscode")
+
+        # Run
+        update_launch_json_for_arduino()
+
+        # Verify
+        with open(".vscode/launch.json") as f:
+            data = json.load(f)
+            self.assertEqual(len(data["configurations"]), 1)
+            config = data["configurations"][0]
+            self.assertEqual(config["name"], "🎯 Auto Debug (Smart File Detection)")
+            self.assertEqual(config["type"], "auto-debug")
+            self.assertIn("*.ino", config["map"])
+
+    @patch("fastled.install.project_detection.is_fastled_repository")
+    def test_safety_clangd_protection(self, mock_repo):
+        """Test 10: 🚨 CRITICAL - clangd safety protection."""
+        # Setup
+        os.makedirs(".vscode")
+
+        # Test non-repository
+        mock_repo.return_value = False
+        update_vscode_settings_for_fastled()
+        self.assertFalse(Path(".vscode/settings.json").exists())
+
+        # Test repository
+        mock_repo.return_value = True
+        update_vscode_settings_for_fastled()
+        self.assertTrue(Path(".vscode/settings.json").exists())
+
+        with open(".vscode/settings.json") as f:
+            data = json.load(f)
+            self.assertIn("clangd.arguments", data)
+
+    @patch("fastled.install.main.check_existing_arduino_content")
+    def test_auto_execution_trigger(self, mock_check):
+        """Test 11: Post-installation auto-execution."""
+        # Setup
+        mock_check.return_value = True
+        original_argv = sys.argv.copy()
+        sys.argv = ["fastled", "--install"]
+
+        try:
+            # We'll test that auto_execute_fastled modifies sys.argv correctly
+            # without actually calling main()
+            with patch("fastled.app.main") as mock_main:
+                mock_main.return_value = 0
+                auto_execute_fastled()
+
+                # Verify
+                mock_main.assert_called_once()
+                # Check that argv was filtered before calling main
+                # The function should have set sys.argv to ['fastled', '.']
+        finally:
+            sys.argv = original_argv
+
+    @patch("fastled.install.project_detection.shutil.which")
+    def test_no_ide_error_handling(self, mock_which):
+        """Test 12: Error when no IDE available."""
+        # Setup
+        mock_which.return_value = None
+
+        # Run
+        from fastled.install.project_detection import validate_vscode_project
+
+        result = validate_vscode_project(no_interactive=True)
+
+        # Verify
+        self.assertFalse(result)
+
+    @patch("subprocess.run")
+    @patch("builtins.input")
+    def test_examples_installation(self, mock_input, mock_run):
+        """Test 13: --project-init examples installation."""
+        # Setup
+        mock_input.return_value = "y"
+        mock_run.return_value = MagicMock(returncode=0)
+
+        # Run
+        from fastled.install.examples_manager import (
+            install_fastled_examples_via_project_init,
+        )
+
+        # Test non-interactive mode - should skip
+        result = install_fastled_examples_via_project_init(no_interactive=True)
+        self.assertFalse(result)
+
+        # Test interactive mode
+        result = install_fastled_examples_via_project_init(no_interactive=False)
+        self.assertTrue(result)
+        mock_run.assert_called_once()
+        call_args = mock_run.call_args[0][0]
+        self.assertEqual(call_args, ["fastled", "--project-init"])
+
+    @patch("fastled.install.extension_manager.download_auto_debug_extension")
+    @patch("fastled.install.extension_manager.install_vscode_extensions")
+    def test_extension_installation_flow(self, mock_install, mock_download):
+        """Test 14: Auto Debug extension prompt/install."""
+        # Setup
+        mock_download.return_value = Path("test.vsix")
+        mock_install.return_value = True
+
+        # Test dry run
+        from fastled.install.extension_manager import install_auto_debug_extension
+
+        result = install_auto_debug_extension(dry_run=True)
+        self.assertTrue(result)
+        mock_download.assert_not_called()
+
+        # Test real install
+        result = install_auto_debug_extension(dry_run=False)
+        self.assertTrue(result)
+        mock_download.assert_called_once()
+        mock_install.assert_called_once()
+
+    @patch("fastled.install.project_detection.is_fastled_repository")
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_comprehensive_integration(self, mock_input, mock_which, mock_repo):
+        """Test 15: End-to-end integration test."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.side_effect = ["y", "y", "y"]  # Yes to project, extension, examples
+        mock_repo.return_value = False
+
+        # Create .vscode first for non-interactive test
+        os.makedirs(".vscode")
+
+        # Run full installation in non-interactive mode
+        result = fastled_install(dry_run=True, no_interactive=True)
+
+        # Verify all components
+        self.assertTrue(result)
+        self.assertTrue(Path(".vscode").exists())
+        self.assertTrue(Path(".vscode/launch.json").exists())
+        self.assertTrue(Path(".vscode/tasks.json").exists())
+
+        # Verify tasks have correct content
+        with open(".vscode/tasks.json") as f:
+            data = json.load(f)
+            debug_task = next(
+                t for t in data["tasks"] if t["label"] == "Run FastLED (Debug)"
+            )
+            self.assertIn("--debug", debug_task["args"])
+            self.assertIn("--app", debug_task["args"])
+
+
+if __name__ == "__main__":
+    unittest.main()

fastled/install/vscode_config.py

@@ -0,0 +1,167 @@
+"""VSCode configuration generation for FastLED projects."""
+
+import json
+from pathlib import Path
+
+
+def update_launch_json_for_arduino() -> None:
+    """Update launch.json with Arduino debugging configuration."""
+    launch_json_path = Path.cwd() / ".vscode" / "launch.json"
+
+    # Default launch configuration
+    arduino_config = {
+        "name": "🎯 Auto Debug (Smart File Detection)",
+        "type": "auto-debug",
+        "request": "launch",
+        "map": {
+            "*.ino": "Arduino: Run .ino with FastLED",
+            "*.py": "Python: Current File (UV)",
+        },
+    }
+
+    if launch_json_path.exists():
+        # Merge with existing
+        try:
+            with open(launch_json_path, "r") as f:
+                data = json.load(f)
+        except json.JSONDecodeError:
+            data = {"version": "0.2.0", "configurations": []}
+    else:
+        data = {"version": "0.2.0", "configurations": []}
+
+    # Check if configuration already exists
+    configs = data.get("configurations", [])
+    exists = any(cfg.get("name") == arduino_config["name"] for cfg in configs)
+
+    if not exists:
+        configs.insert(0, arduino_config)  # Add at the beginning
+        data["configurations"] = configs
+
+    # Write back
+    launch_json_path.parent.mkdir(exist_ok=True)
+    with open(launch_json_path, "w") as f:
+        json.dump(data, f, indent=4)
+
+    print(f"✅ Updated {launch_json_path}")
+
+
+def generate_fastled_tasks() -> None:
+    """Generate/update tasks.json with FastLED build tasks."""
+    tasks_json_path = Path.cwd() / ".vscode" / "tasks.json"
+
+    # FastLED tasks
+    fastled_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": [],
+        },
+    ]
+
+    if tasks_json_path.exists():
+        # Merge with existing
+        try:
+            with open(tasks_json_path, "r") as f:
+                data = json.load(f)
+        except json.JSONDecodeError:
+            data = {"version": "2.0.0", "tasks": []}
+    else:
+        data = {"version": "2.0.0", "tasks": []}
+
+    # Get existing tasks
+    existing_tasks = data.get("tasks", [])
+    existing_labels = {task.get("label") for task in existing_tasks}
+
+    # Add new tasks if they don't exist
+    for task in fastled_tasks:
+        if task["label"] not in existing_labels:
+            existing_tasks.append(task)
+
+    data["tasks"] = existing_tasks
+
+    # Write back
+    tasks_json_path.parent.mkdir(exist_ok=True)
+    with open(tasks_json_path, "w") as f:
+        json.dump(data, f, indent=4)
+
+    print(f"✅ Updated {tasks_json_path}")
+
+
+def update_vscode_settings_for_fastled() -> None:
+    """
+    🚨 Repository-only: Apply clangd settings and IntelliSense overrides.
+    This should ONLY be called for the actual FastLED repository.
+    """
+    from .project_detection import is_fastled_repository
+
+    # Safety check - only apply in actual repository
+    if not is_fastled_repository():
+        return
+    settings_json_path = Path.cwd() / ".vscode" / "settings.json"
+
+    # FastLED repository-specific settings
+    fastled_settings = {
+        "clangd.arguments": [
+            "--compile-commands-dir=${workspaceFolder}/compile_commands",
+            "--header-insertion=never",
+            "--clang-tidy",
+            "--background-index",
+        ],
+        "C_Cpp.intelliSenseEngine": "disabled",
+        "files.associations": {"*.ino": "cpp", "*.h": "cpp", "*.cpp": "cpp"},
+        "editor.formatOnSave": True,
+        "editor.formatOnType": True,
+        "editor.tabSize": 4,
+        "editor.insertSpaces": True,
+    }
+
+    if settings_json_path.exists():
+        # Merge with existing
+        try:
+            with open(settings_json_path, "r") as f:
+                data = json.load(f)
+        except json.JSONDecodeError:
+            data = {}
+    else:
+        data = {}
+
+    # Update settings
+    data.update(fastled_settings)
+
+    # Write back
+    settings_json_path.parent.mkdir(exist_ok=True)
+    with open(settings_json_path, "w") as f:
+        json.dump(data, f, indent=4)
+
+    print(f"✅ Updated {settings_json_path} with FastLED development settings")

fastled/open_browser.py

@@ -15,10 +15,13 @@ _playwright_browser_proxy = None
 
 def cleanup_playwright_browser() -> None:
     """Clean up the Playwright browser on exit."""
-    global _playwright_browser_proxy
-    if _playwright_browser_proxy:
-        _playwright_browser_proxy.close()
-        _playwright_browser_proxy = None
+    try:
+        global _playwright_browser_proxy
+        if _playwright_browser_proxy:
+            _playwright_browser_proxy.close()
+            _playwright_browser_proxy = None
+    except Exception:
+        pass
 
 
 # Register cleanup function

fastled/parse_args.py

@@ -170,6 +170,24 @@ def parse_args() -> Args:
         help="Remove all FastLED containers and images",
     )
 
+    parser.add_argument(
+        "--install",
+        action="store_true",
+        help="Install FastLED development environment with VSCode configuration and Auto Debug extension",
+    )
+
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Run in dry-run mode (simulate actions without making changes)",
+    )
+
+    parser.add_argument(
+        "--no-interactive",
+        action="store_true",
+        help="Run in non-interactive mode (fail instead of prompting for input)",
+    )
+
     build_mode = parser.add_mutually_exclusive_group()
     build_mode.add_argument("--debug", action="store_true", help="Build in debug mode")
     build_mode.add_argument(
@@ -185,6 +203,28 @@ def parse_args() -> Args:
 
     args = parser.parse_args()
 
+    # Auto-enable app mode if debug is used and Playwright cache exists
+    if args.debug and not args.app:
+        playwright_dir = Path.home() / ".fastled" / "playwright"
+        if playwright_dir.exists() and any(playwright_dir.iterdir()):
+            print(
+                "🎭 Detected Playwright cache - automatically enabling app mode for debug"
+            )
+            args.app = True
+        elif not args.no_interactive:
+            # Prompt user to install Playwright only if not in no-interactive mode
+            answer = (
+                input("Would you like to install the FastLED debugger? [y/n] ")
+                .strip()
+                .lower()
+            )
+            if answer in ["y", "yes"]:
+                print(
+                    "📦 To install Playwright, run: pip install playwright && python -m playwright install"
+                )
+                print("Then run your command again with --app flag")
+                sys.exit(0)
+
     # TODO: propagate the library.
     # from fastled.docker_manager import force_remove_previous
 
@@ -204,6 +244,11 @@ def parse_args() -> Args:
     #     print(msg)
     #     set_ramdisk_size(args.ram_disk_size)
 
+    # Handle --install early before other processing
+    if args.install:
+        # Don't process other arguments when --install is used
+        return Args.from_namespace(args)
+
     if args.purge:
         from fastled.docker_manager import DockerManager