fastled 1.4.19__tar.gz → 1.4.33__tar.gz

fastled-1.4.33/.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.33/.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.19 → fastled-1.4.33}/PKG-INFO

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

fastled-1.4.33/chrome_vscode_bridge_design_task.md

@@ -0,0 +1,195 @@
+Here’s a refined `chrome_vscode_bridge_design_task.md` file for your repo. Feel free to adjust paths, placeholders, or formatting to match your project's style.
+
+---
+
+# Chrome ↔ VSCode Bridge Design 🛠️
+
+## Overview
+
+Design and implement a minimal debugging bridge between a Python backend (using a hypothetical `fastled` library) and a Chrome-based frontend, invokable from VS Code. The goal is to allow:
+
+* **Step-through debugging** (`step`, `next`, `in`, `out`)
+* **Program counter**, call stack, local variable inspection
+* Integration with VS Code Python or Node debugger
+
+---
+
+## 📘 Architecture
+
+```
+[VS Code] ↔ [Chrome Frontend CLI: Puppeteer + CDP] ↔ HTTP ↔ [Python Debug API (fastled)]
+```
+
+1. **Backend** (`Python + Flask`)
+
+   * Exposes endpoints:
+
+     * `POST /start` — begins execution, stops at first pause
+     * `POST /step/next` — advances one logical step
+     * `GET /state` — returns `{ pc, function, locals }`
+   * Internally uses generator-based control flow and `inspect` to snapshot state.
+2. **Frontend** (`Node.js + Puppeteer`)
+
+   * Launches Chrome with remote-debugging enabled
+   * Serves a minimal UI (e.g. HTML + JS) to send `start`, `step`, and poll `state`
+   * Renders debugging state to the user; future CDP integration for real-time UI
+3. **VS Code Integration**
+
+   * Launch configuration invokes the frontend script
+   * Stepping and inspection occur in the Chrome UI
+   * Optionally hooks into VS Code Debug Console for unified control
+
+---
+
+## 📄 Files
+
+### 1. `debug_fastled_api.py` (Backend)
+
+```python
+import fastled, inspect
+from flask import Flask, jsonify, request
+
+app = Flask(__name__)
+_state, _step_generator = {}, None
+
+def compute(n):
+    x = n * 2
+    y = fastled.compute(x)
+    yield from report_and_pause()
+    return y
+
+def report_and_pause():
+    frame = inspect.currentframe().f_back
+    _state.update({
+        "pc": frame.f_lineno,
+        "func": frame.f_code.co_name,
+        "locals": frame.f_locals.copy()
+    })
+    yield True
+
+@app.route('/start', methods=['POST'])
+def start():
+    global _step_generator
+    n = request.json.get("n", 5)
+    def runner():
+        gen = compute(n)
+        try: next(gen)
+        except StopIteration: pass
+    _step_generator = runner
+    return jsonify({"status": "started"})
+
+@app.route('/state', methods=['GET'])
+def state():
+    return jsonify(_state)
+
+@app.route('/step/next', methods=['POST'])
+def step_next():
+    try:
+        _step_generator()
+        return jsonify({"status": "paused", **_state})
+    except Exception:
+        return jsonify({"status": "done"})
+
+if __name__ == "__main__":
+    app.run(port=5000)
+```
+
+---
+
+### 2. `debug_fastled_frontend.js` (Frontend)
+
+```js
+const puppeteer = require('puppeteer-core');
+const fetch = require('node-fetch');
+
+(async () => {
+  const browser = await puppeteer.launch({
+    executablePath: '/path/to/chrome',
+    args: ['--remote-debugging-port=9222']
+  });
+  const [page] = await browser.pages();
+
+  const html = `
+    <button id="start">Start</button>
+    <button id="step">Next</button>
+    <pre id="out"></pre>
+    <script>
+      document.getElementById('start').onclick = async () => {
+        await fetch('http://localhost:5000/start', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ n: 10 })
+        });
+        update();
+      };
+      document.getElementById('step').onclick = async () => {
+        await fetch('http://localhost:5000/step/next', { method: 'POST' });
+        update();
+      };
+      async function update() {
+        const res = await fetch('http://localhost:5000/state');
+        document.getElementById('out').textContent = JSON.stringify(await res.json(), null, 2);
+      }
+    </script>
+  `;
+  await page.setContent(html);
+})();
+```
+
+---
+
+## ⛓️ Integration with VS Code
+
+Add this to `.vscode/launch.json`:
+
+```jsonc
+{
+  "configurations": [
+    {
+      "name": "Chrome-FastLED Debug Bridge",
+      "type": "node",
+      "request": "launch",
+      "program": "${workspaceFolder}/debug_fastled_frontend.js"
+    }
+  ]
+}
+```
+
+* Launch this first to start Chrome with debugging enabled
+* Use the UI to `Start`, `Next`, and inspect state output
+* Optionally, add CDP logic to highlight lines in VS Code or Chrome DevTools
+
+---
+
+## ✅ Roadmap & Next Steps
+
+| Task                                    | Status        |
+| --------------------------------------- | ------------- |
+| Generator-based stepping API            | ✅ Implemented |
+| Backend state introspection (PC/locals) | ✅ Implemented |
+| Frontend stepping UI (buttons + state)  | ✅ Implemented |
+| VS Code `launch.json` integration       | ✅ Drafted     |
+| CDP / DevTools integration              | 🔲 To Do      |
+| Support for `step in`, `step out`       | 🔲 To Do      |
+| Breakpoints, multi-file support         | 🔲 To Do      |
+
+---
+
+## 🔧 Future Enhancements
+
+* **Full CDP client**: translate HTTP state to actual Chrome DevTools UI breakpoints/stepping
+* **Rich UI**: live code view, synchronized highlighting, variable inspectors
+* **Language-agnostic bridge**: plug in Node.js or other backends
+* **VS Code Extension support**: unify stepping flows and tooltips
+
+---
+
+## 📎 Summary
+
+This bridge provides:
+
+* A **Python backend** exposing stepping and state via HTTP
+* A **Node.js/pupeteer frontend** for remote-debug Chrome UI
+* **VS Code launch config** for seamless integration
+
+You're all set to explore, refine, or build upon this foundation. Let me know if you'd like help developing CDP integration or full VS Code extension support!

fastled-1.4.33/requirements.docker.txt

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

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

{fastled-1.4.19 → fastled-1.4.33}/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.19 → fastled-1.4.33}/src/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-1.4.19 → fastled-1.4.33}/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(
@@ -122,14 +122,59 @@ def _run_web_compiler(
         (output_dir / "index.html").write_text(error_html, encoding="utf-8")
         return web_result
 
+    # Extract zip contents to fastled_js directory
+    extraction_start_time = time.time()
+    output_dir.mkdir(exist_ok=True)
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+        temp_zip = temp_path / "result.zip"
+        temp_zip.write_bytes(web_result.zip_bytes)
+
+        # Clear existing contents
+        shutil.rmtree(output_dir, ignore_errors=True)
+        output_dir.mkdir(exist_ok=True)
+
+        # Extract zip contents
+        shutil.unpack_archive(temp_zip, output_dir, "zip")
+    extraction_time = time.time() - extraction_start_time
+
     def print_results() -> None:
         hash_value = (
             web_result.hash_value
             if web_result.hash_value is not None
             else "NO HASH VALUE"
         )
+
+        # Build timing breakdown
+        timing_breakdown = f"  Time: {diff:.2f} (seconds)"
+        if hasattr(web_result, "zip_time"):
+            timing_breakdown += f"\n     zip creation: {web_result.zip_time:.2f}"
+            if web_result.libfastled_time > 0:
+                timing_breakdown += (
+                    f"\n     libfastled: {web_result.libfastled_time:.2f}"
+                )
+            timing_breakdown += (
+                f"\n     sketch compile + link: {web_result.sketch_time:.2f}"
+            )
+            if hasattr(web_result, "response_processing_time"):
+                timing_breakdown += f"\n     response processing: {web_result.response_processing_time:.2f}"
+
+            # Calculate any unaccounted time
+            accounted_time = (
+                web_result.zip_time
+                + web_result.libfastled_time
+                + web_result.sketch_time
+                + web_result.response_processing_time
+                + extraction_time
+            )
+            unaccounted_time = diff - accounted_time
+            if extraction_time > 0.01:
+                timing_breakdown += f"\n     extraction: {extraction_time:.2f}"
+            if unaccounted_time > 0.01:
+                timing_breakdown += f"\n     other overhead: {unaccounted_time:.2f}"
+
         print(
-            f"\nWeb compilation successful\n  Time: {diff:.2f}\n  output: {output_dir}\n  hash: {hash_value}\n  zip size: {len(web_result.zip_bytes)} bytes"
+            f"\nWeb compilation successful\n{timing_breakdown}\n  output: {output_dir}\n  hash: {hash_value}\n  zip size: {len(web_result.zip_bytes)} bytes"
         )
 
     # now check to see if the hash value is the same as the last hash value
@@ -138,20 +183,6 @@ def _run_web_compiler(
         print_results()
         return web_result
 
-    # Extract zip contents to fastled_js directory
-    output_dir.mkdir(exist_ok=True)
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-        temp_zip = temp_path / "result.zip"
-        temp_zip.write_bytes(web_result.zip_bytes)
-
-        # Clear existing contents
-        shutil.rmtree(output_dir, ignore_errors=True)
-        output_dir.mkdir(exist_ok=True)
-
-        # Extract zip contents
-        shutil.unpack_archive(temp_zip, output_dir, "zip")
-
     _chunked_print(web_result.stdout)
     print_results()
     return web_result
@@ -255,6 +286,11 @@ def _background_update_docker_image() -> None:
             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}")
 
@@ -489,9 +525,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
@@ -505,6 +538,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:
@@ -516,7 +551,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()

{fastled-1.4.19 → fastled-1.4.33}/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.33/src/fastled/install/__init__.py

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

fastled-1.4.33/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.33/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)