fastled 1.3.30__py3-none-any.whl → 1.4.50__py3-none-any.whl

fastled/install/vscode_config.py

@@ -0,0 +1,344 @@
+"""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 - updated to match the official FastLED repo
+    fastled_settings = {
+        # Terminal configuration
+        "terminal.integrated.defaultProfile.windows": "Git Bash",
+        "terminal.integrated.shellIntegration.enabled": False,
+        "terminal.integrated.profiles.windows": {
+            "Command Prompt": {"path": "C:\\Windows\\System32\\cmd.exe"},
+            "Git Bash": {
+                "path": "C:\\Program Files\\Git\\bin\\bash.exe",
+                "args": ["--cd=."],
+            },
+        },
+        # File settings
+        "files.eol": "\n",  # Unix line endings
+        "files.autoDetectEol": False,  # Prevent VS Code from auto-detecting and changing EOL
+        "files.insertFinalNewline": True,  # Ensure files end with a newline
+        "files.trimFinalNewlines": True,  # Remove extra newlines at the end
+        "editor.tabSize": 4,
+        "editor.insertSpaces": True,
+        "editor.detectIndentation": True,
+        "editor.formatOnSave": False,  # Disabled to prevent conflicts
+        # Debugger defaults - ensure C++ debugger is used for C++ files
+        "debug.defaultDebuggerType": "cppdbg",
+        "debug.toolBarLocation": "docked",
+        "debug.console.fontSize": 14,
+        "debug.console.lineHeight": 19,
+        # Python configuration (using uv as per project rules)
+        "python.defaultInterpreterPath": "uv",
+        "python.debugger": "debugpy",
+        # File associations for debugger
+        "[cpp]": {
+            "editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd",
+            "debug.defaultDebuggerType": "cppdbg",
+        },
+        "[c]": {
+            "editor.defaultFormatter": "ms-vscode.cpptools",
+            "debug.defaultDebuggerType": "cppdbg",
+        },
+        "[ino]": {
+            "editor.defaultFormatter": "ms-vscode.cpptools",
+            "debug.defaultDebuggerType": "cppdbg",
+        },
+        # clangd configuration - enhanced
+        "clangd.arguments": [
+            "--compile-commands-dir=${workspaceFolder}",
+            "--clang-tidy",
+            "--header-insertion=never",
+            "--completion-style=detailed",
+            "--function-arg-placeholders=false",
+            "--background-index",
+            "--pch-storage=memory",
+        ],
+        "clangd.fallbackFlags": [
+            "-std=c++17",
+            "-I${workspaceFolder}/src",
+            "-I${workspaceFolder}/tests",
+            "-Wno-global-constructors",
+        ],
+        # Disable conflicting IntelliSense to let clangd handle C++ analysis
+        "C_Cpp.intelliSenseEngine": "disabled",
+        "C_Cpp.autocomplete": "disabled",
+        "C_Cpp.errorSquiggles": "disabled",
+        "C_Cpp.suggestSnippets": False,
+        "C_Cpp.intelliSenseEngineFallback": "disabled",
+        "C_Cpp.autocompleteAddParentheses": False,
+        "C_Cpp.formatting": "disabled",
+        "C_Cpp.vcpkg.enabled": False,
+        "C_Cpp.configurationWarnings": "disabled",
+        "C_Cpp.intelliSenseCachePath": "",
+        "C_Cpp.intelliSenseCacheSize": 0,
+        "C_Cpp.intelliSenseUpdateDelay": 0,
+        "C_Cpp.workspaceParsingPriority": "lowest",
+        "C_Cpp.disabled": True,
+        # File associations - comprehensive
+        "files.associations": {
+            "*.ino": "cpp",
+            "*.h": "cpp",
+            "*.hpp": "cpp",
+            "*.cpp": "cpp",
+            "*.c": "c",
+            "*.inc": "cpp",
+            "*.tcc": "cpp",
+            "*.embeddedhtml": "html",
+            # Core C++ standard library files
+            "compare": "cpp",
+            "type_traits": "cpp",
+            "cmath": "cpp",
+            "limits": "cpp",
+            "iostream": "cpp",
+            "random": "cpp",
+            "functional": "cpp",
+            "bit": "cpp",
+            "vector": "cpp",
+            "array": "cpp",
+            "string": "cpp",
+            "memory": "cpp",
+            "algorithm": "cpp",
+            "iterator": "cpp",
+            "utility": "cpp",
+            "optional": "cpp",
+            "variant": "cpp",
+            "numeric": "cpp",
+            "chrono": "cpp",
+            "thread": "cpp",
+            "mutex": "cpp",
+            "atomic": "cpp",
+            "future": "cpp",
+            "condition_variable": "cpp",
+        },
+        # Disable Java language support and popups
+        "java.enabled": False,
+        "java.jdt.ls.enabled": False,
+        "java.compile.nullAnalysis.mode": "disabled",
+        "java.configuration.checkProjectSettingsExclusions": False,
+        "java.import.gradle.enabled": False,
+        "java.import.maven.enabled": False,
+        "java.autobuild.enabled": False,
+        "java.maxConcurrentBuilds": 0,
+        "java.recommendations.enabled": False,
+        "java.help.showReleaseNotes": False,
+        "redhat.telemetry.enabled": False,
+        # Java exclusions
+        "java.project.sourcePaths": [],
+        "java.project.referencedLibraries": [],
+        "files.exclude": {
+            "**/.classpath": True,
+            "**/.project": True,
+            "**/.factorypath": True,
+        },
+        # Disable PlatformIO auto-detection for .ino files in FastLED project
+        "platformio.disableToolchainAutoInstaller": True,
+        "platformio-ide.autoRebuildAutocompleteIndex": False,
+        "platformio-ide.activateProjectOnTextEditorChange": False,
+        "platformio-ide.autoOpenPlatformIOIniFile": False,
+        "platformio-ide.autoPreloadEnvTasks": False,
+        "platformio-ide.autoCloseSerialMonitor": False,
+        "platformio-ide.disablePIOHomeStartup": True,
+        # Disable conflicting extensions
+        "extensions.ignoreRecommendations": True,
+        # Semantic token color customizations for better C++ development
+        "editor.semanticTokenColorCustomizations": {
+            "rules": {
+                # Types (classes, structs, enums) - Teal/Cyan
+                "class": "#4EC9B0",
+                "struct": "#4EC9B0",
+                "type": "#4EC9B0",
+                "enum": "#4EC9B0",
+                "enumMember": "#B5CEA8",
+                "typedef": "#4EC9B0",
+                # Variables - Almost pure white for maximum readability
+                "variable": "#FAFAFA",
+                "variable.local": "#FAFAFA",
+                # Parameters - Orange for clear distinction
+                "parameter": "#FF8C42",
+                "variable.parameter": "#FF8C42",
+                # Properties - Light purple/pink
+                "property": "#D197D9",
+                # Functions and methods - Yellow
+                "function": "#DCDCAA",
+                "method": "#DCDCAA",
+                "function.declaration": "#DCDCAA",
+                "method.declaration": "#DCDCAA",
+                # Namespaces - Soft blue
+                "namespace": "#86C5F7",
+                # Constants and readonly - Light green with italic
+                "variable.readonly": {"foreground": "#B5CEA8", "fontStyle": "italic"},
+                "variable.defaultLibrary": "#B5CEA8",
+                # Macros and defines - Muted red/salmon
+                "macro": "#E06C75",
+                # String literals - Peach/salmon
+                "string": "#CE9178",
+                # Numbers - Light green
+                "number": "#B5CEA8",
+                # Keywords - Pink/magenta
+                "keyword": "#C586C0",
+                # Storage specifiers - Bright magenta/pink
+                "keyword.storage": "#FF79C6",
+                "storageClass": "#FF79C6",
+                # Built-in types - Different from user-defined types
+                "type.builtin": "#569CD6",
+                "keyword.type": "#569CD6",
+                # Comments - Green
+                "comment": "#6A9955",
+                "comment.documentation": "#6A9955",
+            }
+        },
+        # Inlay hints - Brighter gray for better visibility
+        "editor.inlayHints.fontColor": "#808080",
+        "editor.inlayHints.background": "#3C3C3C20",
+    }
+
+    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 comprehensive FastLED development settings"
+    )

fastled/interruptible_http.py

@@ -0,0 +1,148 @@
+"""
+Interruptible HTTP requests that can be cancelled with Ctrl+C.
+
+This module provides cross-platform HTTP request functionality that can be
+interrupted with Ctrl+C by using asyncio cancellation and periodic checks.
+"""
+
+import asyncio
+
+import httpx
+
+
+class InterruptibleHTTPRequest:
+    """A wrapper for making HTTP requests that can be interrupted by Ctrl+C."""
+
+    def __init__(self):
+        self.cancelled = False
+
+    async def _make_request_async(
+        self,
+        url: str,
+        files: dict,
+        headers: dict,
+        transport: httpx.HTTPTransport | None = None,
+        timeout: float = 240,
+        follow_redirects: bool = True,
+    ) -> httpx.Response:
+        """Make an async HTTP request."""
+        # Convert sync transport to async transport if provided
+        async_transport = None
+        if transport is not None:
+            # For IPv4 connections, create async transport with local address
+            async_transport = httpx.AsyncHTTPTransport(local_address="0.0.0.0")
+
+        async with httpx.AsyncClient(
+            transport=async_transport,
+            timeout=timeout,
+        ) as client:
+            response = await client.post(
+                url,
+                follow_redirects=follow_redirects,
+                files=files,
+                headers=headers,
+            )
+            return response
+
+    def make_request_interruptible(
+        self,
+        url: str,
+        files: dict,
+        headers: dict,
+        transport: httpx.HTTPTransport | None = None,
+        timeout: float = 240,
+        follow_redirects: bool = True,
+    ) -> httpx.Response:
+        """Make an HTTP request that can be interrupted by Ctrl+C."""
+        try:
+            # Create a new event loop if we're not in one
+            try:
+                loop = asyncio.get_running_loop()
+                # We're already in an event loop, use run_in_executor
+                return asyncio.run_coroutine_threadsafe(
+                    self._run_with_keyboard_check(
+                        url, files, headers, transport, timeout, follow_redirects
+                    ),
+                    loop,
+                ).result()
+            except RuntimeError:
+                # No running loop, create one
+                return asyncio.run(
+                    self._run_with_keyboard_check(
+                        url, files, headers, transport, timeout, follow_redirects
+                    )
+                )
+        except KeyboardInterrupt:
+            print("\nHTTP request cancelled by user")
+            raise
+
+    async def _run_with_keyboard_check(
+        self,
+        url: str,
+        files: dict,
+        headers: dict,
+        transport: httpx.HTTPTransport | None = None,
+        timeout: float = 240,
+        follow_redirects: bool = True,
+    ) -> httpx.Response:
+        """Run the request with periodic keyboard interrupt checks."""
+        task = asyncio.create_task(
+            self._make_request_async(
+                url, files, headers, transport, timeout, follow_redirects
+            )
+        )
+
+        # Poll for keyboard interrupt while waiting for the request
+        # This approach allows the task to be cancelled when KeyboardInterrupt
+        # is raised in the calling thread
+        while not task.done():
+            try:
+                # Wait for either completion or a short timeout
+                response = await asyncio.wait_for(asyncio.shield(task), timeout=0.1)
+                return response
+            except asyncio.TimeoutError:
+                # Continue waiting - the short timeout allows for more responsive
+                # cancellation when KeyboardInterrupt is raised
+                continue
+            except KeyboardInterrupt:
+                task.cancel()
+                print("\nHTTP request cancelled by user")
+                raise
+
+        return await task
+
+
+def make_interruptible_post_request(
+    url: str,
+    files: dict | None = None,
+    headers: dict | None = None,
+    transport: httpx.HTTPTransport | None = None,
+    timeout: float = 240,
+    follow_redirects: bool = True,
+) -> httpx.Response:
+    """
+    Convenience function to make an interruptible POST request.
+
+    Args:
+        url: The URL to make the request to
+        files: Files to upload (optional)
+        headers: HTTP headers (optional)
+        transport: HTTP transport to use (optional)
+        timeout: Request timeout in seconds
+        follow_redirects: Whether to follow redirects
+
+    Returns:
+        The HTTP response
+
+    Raises:
+        KeyboardInterrupt: If the request was cancelled by Ctrl+C
+    """
+    request_handler = InterruptibleHTTPRequest()
+    return request_handler.make_request_interruptible(
+        url=url,
+        files=files or {},
+        headers=headers or {},
+        transport=transport,
+        timeout=timeout,
+        follow_redirects=follow_redirects,
+    )

fastled/live_client.py

@@ -22,6 +22,8 @@ class LiveClient:
         keep_running: bool = True,
         build_mode: BuildMode = BuildMode.QUICK,
         profile: bool = False,
+        no_platformio: bool = False,
+        enable_https: bool = True,  # Enable HTTPS for the local server
     ) -> None:
         self.sketch_directory = sketch_directory
         self.host = host
@@ -34,6 +36,8 @@ class LiveClient:
         self.shutdown = threading.Event()
         self.thread: threading.Thread | None = None
         self.auto_updates = auto_updates
+        self.no_platformio = no_platformio
+        self.enable_https = enable_https
         if auto_start:
             self.start()
         if self.auto_updates is False:
@@ -52,18 +56,22 @@ class LiveClient:
             profile=self.profile,
             shutdown=self.shutdown,
             http_port=self.http_port,
+            no_platformio=self.no_platformio,
+            enable_https=self.enable_https,
         )
         return rtn
 
     def url(self) -> str:
         """Get the URL of the server."""
+        from fastled.settings import SERVER_PORT
+
         if isinstance(self.host, CompileServer):
             return self.host.url()
         if self.host is None:
             import warnings
 
             warnings.warn("TODO: use the actual host.")
-            return "http://localhost:9021"
+            return f"http://localhost:{SERVER_PORT}"
         return self.host
 
     @property
@@ -94,3 +102,15 @@ class LiveClient:
 
     def __exit__(self, exc_type, exc_value, traceback) -> None:
         self.finalize()
+
+    def get_emsdk_headers(self, filepath: Path) -> None:
+        """Get EMSDK headers ZIP data from the server and save to filepath."""
+        if isinstance(self.host, CompileServer):
+            self.host.get_emsdk_headers(filepath)
+        else:
+            # Handle string host or None case by using web_compile approach
+            from fastled.settings import DEFAULT_URL
+            from fastled.util import download_emsdk_headers
+
+            base_url = self.host if isinstance(self.host, str) else DEFAULT_URL
+            download_emsdk_headers(base_url, filepath)