fastled 1.2.55__py3-none-any.whl → 1.2.57__py3-none-any.whl

fastled/__init__.py

@@ -13,7 +13,7 @@ from .types import BuildMode, CompileResult, CompileServerError
 # 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.2.55"
+__version__ = "1.2.57"
 
 DOCKER_FILE = (
     "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/Dockerfile"

fastled/assets/localhost-key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDlxbWcpUXPpjqs
+DJPgFF1FsXPZqq0JPJqssHh4ZLfN0h4yJmj+kRcHS+pkgXnG46g6bUcL/AK5Ba08
+vwnUUGkPH0v4ShKiAGYwvOcbWaqTmvvJuIoaDBXh2jSCeOTagNoaHLYEugARkkEu
+0/FEW5P/79wU5vJ5G+SyZ8rBCVdxlU57pL1hKWBU7K+BLWsCiZ308NMpzHF5APZ6
+YxVjhFosJPr4TjN6yXr+whrsAjSTHamD5690MbXWyyPG0jwPQyjBot/cNtt8GrsN
+gcjA1E+8VKFvxO8RvZanMZLb0CGEpt7u3oaJ/jprHEsw+/UhnG6Qhksm8C/DN9kP
+hselewffAgMBAAECggEARjQ6YTo+Mkvf8WGGbRjLxteJRiBX7lKOD+V7aY2ce06P
+21LREbbTCm+vljXZN2OnqvJomsjNLCsH21+jaTOIZg5x79LyDn2Au7N8CWdELwVT
+mTbBO2Ql63P4R0UY54onGYNcOeV6z+OX9u7a8L/qYHCxFdHalBZpsfj0gjaQeStJ
+JSnvGjo6tKkwC/nUmX01qEVQgUO1+39WYqCaIWjijZNXt6XiKclEuu1AkL0u6Mpt
+CzvzEDrEA66D0Lvl3Tek9B4O16Oie5anNnNMHigwU9yVc6dI8vDCRSEiz7laPTFK
+xzOCQmqPGClKXkX3U+OvZp/Ss9U26Wpu0AbRKTvzAQKBgQDsMR9NjMpOmUaWkAwl
+1wlUxsZ9YkRuTy7R3RfIdYWj6Lcoc4/iN0qILFM7xidkHhYTFqnsnP1SQkV6lEHV
+OalYxZu9F2l1rHPc8G5YWh/KOg1rAEI47MVT4iwhA2fw6JLti/rm25AeSTMjSTqu
+ht3146036opcIF3v86oGUrSXDwKBgQD5CsNcwLeUDGXozjq62T8/mTYwd2Tw3aiY
+KaGp+exAW321vYm5SKsMitBMGU2tGFlv5eptSI48h7SCpgnszaexw7yj30KuvqjG
+bBqq/MsKuXHyn2sG0A7MJ6zfk+4l46B45blDJZ+x7xL0dyS4UCU3zUeesgSGo4zK
+ZOspPIQCMQKBgQCk35VuWP1P6IbxyxPvxi/pUeh01gfWyMdyD9fuQrtLM8PHJQQn
+cVlBvU9MxoHwzV+za3qqhNwAc+p0KtHZuiqQoUCZuqIPVpZ6gAtG+YJ/dA6xxrhz
+bDRC3frYALyp2m/WCoTWaiYsPgTIePHRqqt+XbQo+DwlGyL3wSvKxijx2QKBgCb0
+OwioEE70/X/DukX9szn0chh0pHJUiYl7gZD/yadraCdkRUWZC0BD+j7c+lxn4Z1y
+HhAH+E+Zfm+tHwJOTLuufTQ4uMpygh2/TRCPyAaeaSdlLi17n8TpM84o6mg8yZ3/
+eNH68Za4aYOZm0HFL30h++DjwXd534zM6keh8pgRAoGBAKUrsjDGjuSo8l1fi4Cq
+INu/rQop2h/db02zyJP5q7NKhE1nqogeLwwn+2M/LtHQ1nIzZR+rvrLNgt6oWY31
+sPsv8JUfVT8GmdhU9KKmizK6eUu3rWdj2+rJARmuEaPmHcD5O6oJaGU0qadqQP34
+H+enwWmpyZXAIbEu/q63DFhV
+-----END PRIVATE KEY-----

fastled/assets/localhost.pem

@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEfTCCAuWgAwIBAgIRAPb7jkLrCuqToG+s3AQYeuUwDQYJKoZIhvcNAQELBQAw
+gakxHjAcBgNVBAoTFW1rY2VydCBkZXZlbG9wbWVudCBDQTE/MD0GA1UECww2REVT
+S1RPUC1JMzcxOERPXFphY2ggVm9yaGllc0BERVNLVE9QLUkzNzE4RE8gKG5pdGVy
+aXMpMUYwRAYDVQQDDD1ta2NlcnQgREVTS1RPUC1JMzcxOERPXFphY2ggVm9yaGll
+c0BERVNLVE9QLUkzNzE4RE8gKG5pdGVyaXMpMB4XDTI1MDQyODAwMzk1MFoXDTI3
+MDcyODAwMzk1MFowajEnMCUGA1UEChMebWtjZXJ0IGRldmVsb3BtZW50IGNlcnRp
+ZmljYXRlMT8wPQYDVQQLDDZERVNLVE9QLUkzNzE4RE9cWmFjaCBWb3JoaWVzQERF
+U0tUT1AtSTM3MThETyAobml0ZXJpcykwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
+ggEKAoIBAQDlxbWcpUXPpjqsDJPgFF1FsXPZqq0JPJqssHh4ZLfN0h4yJmj+kRcH
+S+pkgXnG46g6bUcL/AK5Ba08vwnUUGkPH0v4ShKiAGYwvOcbWaqTmvvJuIoaDBXh
+2jSCeOTagNoaHLYEugARkkEu0/FEW5P/79wU5vJ5G+SyZ8rBCVdxlU57pL1hKWBU
+7K+BLWsCiZ308NMpzHF5APZ6YxVjhFosJPr4TjN6yXr+whrsAjSTHamD5690MbXW
+yyPG0jwPQyjBot/cNtt8GrsNgcjA1E+8VKFvxO8RvZanMZLb0CGEpt7u3oaJ/jpr
+HEsw+/UhnG6Qhksm8C/DN9kPhselewffAgMBAAGjXjBcMA4GA1UdDwEB/wQEAwIF
+oDATBgNVHSUEDDAKBggrBgEFBQcDATAfBgNVHSMEGDAWgBSPBydvhr9wI+FsoW/H
+WK3DbS8IUDAUBgNVHREEDTALgglsb2NhbGhvc3QwDQYJKoZIhvcNAQELBQADggGB
+AJVrF1yczZaxt+A2AhdeFbJQUR6NzGBTc20YeWF1YzLV5sV3QVumwZLP2M9ggRgd
+xWV0xfwUHobFQk6RIPTADcLKctiurql0cgF4DPnpWVvto9RM00U3AkQcMj3xtKBV
+wUqo83TcbqgL+euudFZ09gGTs9u9AENaZPcMh+rW8DDO92t+EwMI/IfopxVOJGUB
+RSM3yTwV93BMYBuddt8mclzLzPK/1WONfsHU2xEascaHR1tYMOmJN9Vq4o0fzWxo
+a2vI6K0aJqZV/ztdXq3akwLc6/e9hyptHWa0i/022xVCyNWIlnuEhT7ENMPxh6rX
+ZCQCZVnhcSWAyFjggLJql3aSID5fPF8rmN7wWsB/I5pl9qwMR1/THMPrm5aWn1Xj
+xW6PxkSGm73kd57DH7tqm5HTd8eYCbnsFofI9rC7xI6HCfwchKp+YHvIEu/LJ56E
+FLnCZW/orYkHCzWntzxv1bddrw1BwaNR8Q+mu3imRP8fuyXb2UkFkINVVyOOWHuW
+Kw==
+-----END CERTIFICATE-----

fastled/filewatcher.py

@@ -1,5 +1,6 @@
 """File system watcher implementation using watchdog"""
 
+import _thread
 import hashlib
 import os
 import queue
@@ -229,34 +230,11 @@ class FileWatcherProcess:
         return changed_files
 
 
-# DEBOUNCE_SECONDS = 4
-# LAST_TIME = 0.0
-# WATCHED_FILES: list[str] = []
-
-# def debounced_sketch_filewatcher_get_all_changes() -> list[str]:
-#     nonlocal DEBOUNCE_SECONDS
-#     nonlocal LAST_TIME
-#     nonlocal WATCHED_FILES
-#     current_time = time.time()
-#     new_files = sketch_filewatcher.get_all_changes()
-#     if new_files:
-#         WATCHED_FILES.extend(new_files)
-#         print(f"Changes detected in {new_files}")
-#         LAST_TIME = current_time
-#         return []
-#     diff = current_time - LAST_TIME
-#     if diff > DEBOUNCE_SECONDS and len(WATCHED_FILES) > 0:
-#         LAST_TIME = current_time
-#         WATCHED_FILES, changed_files = [], WATCHED_FILES
-#         changed_files = sorted(list(set(changed_files)))
-#         return changed_files
-#     return []
-
-
-class DebouncedFileWatcherProcess:
+class DebouncedFileWatcherProcess(threading.Thread):
     """
     Wraps a FileWatcherProcess to batch rapid-fire change events
     and only emit them once the debounce interval has passed.
+    Runs in its own thread, polling every 0.1 s.
     """
 
     def __init__(
@@ -264,35 +242,62 @@ class DebouncedFileWatcherProcess:
         watcher: FileWatcherProcess,
         debounce_seconds: float = FILE_CHANGED_DEBOUNCE_SECONDS,
     ) -> None:
+        super().__init__(daemon=True)
         self.watcher = watcher
         self.debounce_seconds = debounce_seconds
-        self._last_time = 0.0
-        self._watched_files: list[str] = []
+
+        # internal buffer & timing
+        self._buffer: list[str] = []
+        self._last_time: float = 0.0
+
+        # queue of flushed batches
+        self._out_queue: queue.Queue[list[str]] = queue.Queue()
+        self._stop_event = threading.Event()
+
+        # record timestamp of last event for external inspection
+        self.last_event_time: float | None = None
+
+        self.start()
+
+    def run(self) -> None:
+        try:
+            while not self._stop_event.is_set():
+                now = time.time()
+                # non-blocking poll of raw watcher events
+                new = self.watcher.get_all_changes(timeout=0)
+                if new:
+                    self._buffer.extend(new)
+                    self._last_time = now
+                    self.last_event_time = now
+
+                # if buffer exists and debounce interval elapsed, flush it
+                if self._buffer and (now - self._last_time) > self.debounce_seconds:
+                    batch = sorted(set(self._buffer))
+                    self._buffer.clear()
+                    self._last_time = now
+                    self._out_queue.put(batch)
+
+                time.sleep(0.1)
+        except KeyboardInterrupt:
+            _thread.interrupt_main()
+            raise
 
     def get_all_changes(self, timeout: float | None = None) -> list[str]:
         """
-        Polls the underlying watcher for raw events, accumulates them,
-        and once no new events arrive for `debounce_seconds`, flushes
-        a sorted, unique list of paths.
+        Return the next debounced batch of paths, or [] if none arrives
+        within `timeout` seconds.
         """
-        now = time.time()
-        # pull in any new raw events
-        new = self.watcher.get_all_changes(timeout=timeout)
-        if new:
-            self._watched_files.extend(new)
-            # reset the window
-            self._last_time = now
+        try:
+            if timeout is None:
+                # non-blocking
+                return self._out_queue.get_nowait()
+            else:
+                return self._out_queue.get(timeout=timeout)
+        except queue.Empty:
             return []
 
-        # if the window has elapsed, flush
-        if self._watched_files and (now - self._last_time) > self.debounce_seconds:
-            batch = sorted(set(self._watched_files))
-            self._watched_files.clear()
-            self._last_time = now
-            return batch
-
-        return []
-
     def stop(self) -> None:
-        """Tear down the underlying watcher process."""
+        """Stop the polling thread and tear down the underlying watcher."""
+        self._stop_event.set()
+        self.join()
         self.watcher.stop()

fastled/keyz.py

@@ -0,0 +1,30 @@
+import importlib.resources as pkg_resources
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class SslConfig:
+    certfile: Path
+    keyfile: Path
+
+
+def get_asset_path(filename: str) -> Path | None:
+    """Locate a file from the fastled.assets package resources."""
+    try:
+        resource = pkg_resources.files("fastled.assets").joinpath(filename)
+        # Convert to Path for file-system access
+        path = Path(str(resource))
+        return path if path.exists() else None
+    except (ModuleNotFoundError, AttributeError):
+        return None
+
+
+def get_ssl_config() -> SslConfig:
+    """Get the keys for the server"""
+    certfile = get_asset_path("localhost-key.pem")
+    keyfile = get_asset_path("localhost.pem")
+    if certfile is None or keyfile is None:
+        raise ValueError("Could not find keys for server")
+    # return certfile, keyfile
+    return SslConfig(certfile=certfile, keyfile=keyfile)

fastled/open_browser.py

@@ -5,30 +5,23 @@ import webbrowser
 from multiprocessing import Process
 from pathlib import Path
 
-DEFAULT_PORT = 8089  # different than live version.
+from fastled.keyz import get_ssl_config
 
+DEFAULT_PORT = 8089  # different than live version.
 PYTHON_EXE = sys.executable
+SSL_CONFIG = get_ssl_config()
+
+
+# print(f"SSL Config: {SSL_CONFIG.certfile}, {SSL_CONFIG.keyfile}")
 
 
 def open_http_server_subprocess(
-    fastled_js: Path, port: int, open_browser: bool
+    fastled_js: Path,
+    port: int,
+    open_browser: bool,
 ) -> None:
-    """Start livereload server in the fastled_js directory and return the process"""
-    import shutil
-
     try:
-        if shutil.which("live-server") is not None:
-            cmd = [
-                "live-server",
-                f"--port={port}",
-                "--host=localhost",
-                ".",
-            ]
-            if not open_browser:
-                cmd.append("--no-browser")
-            subprocess.run(cmd, shell=True, cwd=fastled_js)
-            return
-
+        # Fallback to our Python server
         cmd = [
             PYTHON_EXE,
             "-m",
@@ -37,8 +30,23 @@ def open_http_server_subprocess(
             "--port",
             str(port),
         ]
-        # return subprocess.Popen(cmd)  # type ignore
-        # pipe stderr and stdout to null
+        if open_browser:
+            cmd.append("--open-browser")
+        # Pass SSL flags if available
+        if SSL_CONFIG.certfile and SSL_CONFIG.keyfile:
+            cmd.extend(
+                [
+                    "--cert",
+                    str(SSL_CONFIG.certfile),
+                    "--key",
+                    str(SSL_CONFIG.keyfile),
+                ]
+            )
+        print(
+            f"Running server on port {port} with certs: {SSL_CONFIG.certfile}, {SSL_CONFIG.keyfile}"
+        )
+        print(f"Command: {subprocess.list2cmdline(cmd)}")
+        # Suppress output
         subprocess.run(
             cmd,
             stdout=subprocess.DEVNULL,
@@ -87,54 +95,34 @@ def wait_for_server(port: int, timeout: int = 10) -> None:
     raise TimeoutError("Could not connect to server")
 
 
-def _background_npm_install_live_server() -> None:
-    import shutil
-    import time
-
-    if shutil.which("npm") is None:
-        return
-
-    if shutil.which("live-server") is not None:
-        return
-
-    time.sleep(3)
-    subprocess.run(
-        ["npm", "install", "-g", "live-server"],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-
-
 def open_browser_process(
-    fastled_js: Path, port: int | None = None, open_browser: bool = True
+    fastled_js: Path,
+    port: int | None = None,
+    open_browser: bool = True,
 ) -> Process:
-    import shutil
 
-    """Start livereload server in the fastled_js directory and return the process"""
-    if port is not None:
-        if not is_port_free(port):
-            raise ValueError(f"Port {port} was specified but in use")
-    else:
+    if port is not None and not is_port_free(port):
+        raise ValueError(f"Port {port} was specified but in use")
+    if port is None:
         port = find_free_port(DEFAULT_PORT)
-    out: Process = Process(
+
+    proc = Process(
         target=open_http_server_subprocess,
-        args=(fastled_js, port, False),
+        args=(fastled_js, port, open_browser),
         daemon=True,
     )
-    out.start()
+    proc.start()
     wait_for_server(port)
     if open_browser:
-        print(f"Opening browser to http://localhost:{port}")
-        webbrowser.open(url=f"http://localhost:{port}", new=1, autoraise=True)
-
-    # start a deamon thread to install live-server
-    if shutil.which("live-server") is None:
-        import threading
-
-        t = threading.Thread(target=_background_npm_install_live_server)
-        t.daemon = True
-        t.start()
-    return out
+        print(
+            f"Opening browser to http{'s' if SSL_CONFIG.certfile else ''}://localhost:{port}"
+        )
+        webbrowser.open(
+            url=f"http{'s' if SSL_CONFIG.certfile else ''}://localhost:{port}",
+            new=1,
+            autoraise=True,
+        )
+    return proc
 
 
 if __name__ == "__main__":
@@ -144,9 +132,7 @@ if __name__ == "__main__":
         description="Open a browser to the fastled_js directory"
     )
     parser.add_argument(
-        "fastled_js",
-        type=Path,
-        help="Path to the fastled_js directory",
+        "fastled_js", type=Path, help="Path to the fastled_js directory"
     )
     parser.add_argument(
         "--port",

fastled/open_browser2.py

@@ -1,90 +1,56 @@
 import argparse
+import importlib.resources as pkg_resources
 from pathlib import Path
 
-from livereload import Server
+from .server_fastapi_cli import run_fastapi_server_proces
 
 
-def _run_flask_server(fastled_js: Path, port: int) -> None:
-    """Run Flask server with live reload in a subprocess"""
+def get_asset_path(filename: str) -> Path | None:
+    """Locate a file from the fastled.assets package resources."""
     try:
-        from flask import Flask, send_from_directory
-
-        app = Flask(__name__)
-
-        # Must be a full path or flask will fail to find the file.
-        fastled_js = fastled_js.resolve()
-
-        @app.route("/")
-        def serve_index():
-            return send_from_directory(fastled_js, "index.html")
-
-        @app.route("/<path:path>")
-        def serve_files(path):
-            response = send_from_directory(fastled_js, path)
-            # Some servers don't set the Content-Type header for a bunch of files.
-            if path.endswith(".js"):
-                response.headers["Content-Type"] = "application/javascript"
-            if path.endswith(".css"):
-                response.headers["Content-Type"] = "text/css"
-            if path.endswith(".wasm"):
-                response.headers["Content-Type"] = "application/wasm"
-            if path.endswith(".json"):
-                response.headers["Content-Type"] = "application/json"
-            if path.endswith(".png"):
-                response.headers["Content-Type"] = "image/png"
-            if path.endswith(".jpg"):
-                response.headers["Content-Type"] = "image/jpeg"
-            if path.endswith(".jpeg"):
-                response.headers["Content-Type"] = "image/jpeg"
-            if path.endswith(".gif"):
-                response.headers["Content-Type"] = "image/gif"
-            if path.endswith(".svg"):
-                response.headers["Content-Type"] = "image/svg+xml"
-            if path.endswith(".ico"):
-                response.headers["Content-Type"] = "image/x-icon"
-            if path.endswith(".html"):
-                response.headers["Content-Type"] = "text/html"
-
-            # now also add headers to force no caching
-            response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
-            response.headers["Pragma"] = "no-cache"
-            response.headers["Expires"] = "0"
-            return response
-
-        server = Server(app.wsgi_app)
-        # Watch index.html for changes
-        server.watch(str(fastled_js / "index.html"))
-        # server.watch(str(fastled_js / "index.js"))
-        # server.watch(str(fastled_js / "index.css"))
-        # Start the server
-        server.serve(port=port, debug=True)
-    except KeyboardInterrupt:
-        import _thread
-
-        _thread.interrupt_main()
-    except Exception as e:
-        print(f"Failed to run Flask server: {e}")
-        import _thread
-
-        _thread.interrupt_main()
-
-
-def run(path: Path, port: int) -> None:
-    """Run the Flask server."""
+        resource = pkg_resources.files("fastled.assets").joinpath(filename)
+        # Convert to Path for file-system access
+        path = Path(str(resource))
+        return path if path.exists() else None
+    except (ModuleNotFoundError, AttributeError):
+        return None
+
+
+def _open_browser(url: str) -> None:
+    import webview
+
+    webview.create_window("FastLED", url, fullscreen=True)
+    webview.start()
+
+
+def run(
+    path: Path,
+    port: int,
+    open_browser: bool,
+    certfile: Path | None = None,
+    keyfile: Path | None = None,
+) -> None:
+    """Run the server, using package assets if explicit paths are not provided"""
+    # Use package resources if no explicit path
+    if certfile is None:
+        certfile = get_asset_path("localhost.pem")
+    if keyfile is None:
+        keyfile = get_asset_path("localhost-key.pem")
+
+    # _run_flask_server(path, port, certfile, keyfile)
+    # run_fastapi_server_proces(port=port, path=path, certfile=certfile, keyfile=keyfile)
+    proc = run_fastapi_server_proces(port=port, cwd=path)
+    if open_browser:
+        _open_browser(f"http://localhost:{port}/")
     try:
-        _run_flask_server(path, port)
-        import warnings
-
-        warnings.warn("Flask server has stopped")
+        proc.join()
     except KeyboardInterrupt:
         import _thread
 
         _thread.interrupt_main()
-        pass
 
 
 def parse_args() -> argparse.Namespace:
-    """Parse the command line arguments."""
     parser = argparse.ArgumentParser(
         description="Open a browser to the fastled_js directory"
     )
@@ -95,16 +61,36 @@ def parse_args() -> argparse.Namespace:
         "--port",
         "-p",
         type=int,
-        required=True,
-        help="Port to run the server on (default: %(default)s)",
+        default=5500,
+        help="Port to run the server on (default: 5500)",
+    )
+    parser.add_argument(
+        "--cert", type=Path, help="(Optional) Path to SSL certificate (PEM format)"
+    )
+    parser.add_argument(
+        "--key", type=Path, help="(Optional) Path to SSL private key (PEM format)"
+    )
+    parser.add_argument(
+        "--open-browser",
+        action="store_true",
     )
     return parser.parse_args()
 
 
 def main() -> None:
-    """Main function."""
     args = parse_args()
-    run(args.fastled_js, args.port)
+    open_browser: bool = args.open_browser
+    fastled_js: Path = args.fastled_js
+    port: int = args.port
+    cert: Path | None = args.cert
+    key: Path | None = args.key
+    run(
+        path=fastled_js,
+        port=port,
+        open_browser=open_browser,
+        certfile=cert,
+        keyfile=key,
+    )
 
 
 if __name__ == "__main__":

fastled/server_fastapi.py

@@ -0,0 +1,60 @@
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+
+# your existing MIME mapping, e.g.
+MAPPING = {
+    "js": "application/javascript",
+    "css": "text/css",
+    "wasm": "application/wasm",
+    "json": "application/json",
+    "png": "image/png",
+    "jpg": "image/jpeg",
+    "jpeg": "image/jpeg",
+    "gif": "image/gif",
+    "svg": "image/svg+xml",
+    "ico": "image/x-icon",
+    "html": "text/html",
+}
+
+
+"""Run FastAPI server with live reload or HTTPS depending on args."""
+app = FastAPI()
+base = Path(".")
+
+
+def no_cache_headers() -> dict[str, str]:
+    return {
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        "Pragma": "no-cache",
+        "Expires": "0",
+    }
+
+
+@app.get("/")
+async def serve_index():
+    index_path = base / "index.html"
+    if not index_path.exists():
+        raise HTTPException(status_code=404, detail="index.html not found")
+    return FileResponse(
+        index_path,
+        media_type=MAPPING.get("html"),
+        headers=no_cache_headers(),
+    )
+
+
+@app.get("/{path:path}")
+async def serve_files(path: str):
+    file_path = base / path
+    if not file_path.exists() or not file_path.is_file():
+        raise HTTPException(status_code=404, detail=f"{path} not found")
+
+    ext = path.rsplit(".", 1)[-1].lower()
+    media_type = MAPPING.get(ext)
+
+    return FileResponse(
+        file_path,
+        media_type=media_type,
+        headers=no_cache_headers(),
+    )

fastled/server_fastapi_cli.py

@@ -0,0 +1,60 @@
+from multiprocessing import Process
+from pathlib import Path
+
+import uvicorn
+
+# MAPPING = {
+#     "js": "application/javascript",
+#     "css": "text/css",
+#     "wasm": "application/wasm",
+#     "json": "application/json",
+#     "png": "image/png",
+#     "jpg": "image/jpeg",
+#     "jpeg": "image/jpeg",
+#     "gif": "image/gif",
+#     "svg": "image/svg+xml",
+#     "ico": "image/x-icon",
+#     "html": "text/html",
+# }
+
+
+def _run_fastapi_server(
+    port: int,
+    cwd: Path,
+    certfile: Path | None = None,
+    keyfile: Path | None = None,
+) -> None:
+    # Uvicorn “reload” will watch your Python files for changes.
+    import os
+
+    os.chdir(cwd)
+    uvicorn.run(
+        "fastled.server_fastapi:app",
+        host="127.0.0.1",
+        port=port,
+        reload=True,
+        ssl_certfile=certfile,
+        ssl_keyfile=keyfile,
+    )
+
+
+def run_fastapi_server_proces(
+    port: int,
+    cwd: Path | None = None,
+    certfile: Path | None = None,
+    keyfile: Path | None = None,
+) -> Process:
+    """Run the FastAPI server in a separate process."""
+    cwd = cwd or Path(".")
+    process = Process(
+        target=_run_fastapi_server,
+        args=(port, cwd, certfile, keyfile),
+    )
+    process.start()
+    return process
+
+
+if __name__ == "__main__":
+    # Example usage
+    proc = run_fastapi_server_proces(port=8000)
+    proc.join()

fastled/settings.py

@@ -1,7 +1,7 @@
 import os
 import platform
 
-FILE_CHANGED_DEBOUNCE_SECONDS = 4.0
+FILE_CHANGED_DEBOUNCE_SECONDS = 2.0
 MACHINE = platform.machine().lower()
 IS_ARM: bool = "arm" in MACHINE or "aarch64" in MACHINE
 PLATFORM_TAG: str = "-arm64" if IS_ARM else ""

fastled/string_diff.py

@@ -13,10 +13,26 @@ def string_diff(
     def normalize(s: str) -> str:
         return s.lower() if ignore_case else s
 
-    # distances = [
-    #     #Levenshtein.distance(normalize(input_string), normalize(s)) for s in string_list
-    #     fuzz.partial_ratio(normalize(input_string), normalize(s)) for s in string_list
-    # ]
+    map_string: dict[str, str] = {}
+
+    if ignore_case:
+        map_string = {s.lower(): s for s in string_list}
+    else:
+        map_string = {s: s for s in string_list}
+
+    if ignore_case:
+        string_list = [s.lower() for s in string_list]
+        input_string = input_string.lower()
+
+    is_substring = False
+    for s in string_list:
+        if input_string in s:
+            is_substring = True
+            break
+
+    if is_substring:
+        string_list = [s for s in string_list if input_string in s]
+
     distances: list[float] = []
     for s in string_list:
         dist = fuzz.token_sort_ratio(normalize(input_string), normalize(s))
@@ -25,7 +41,9 @@ def string_diff(
     out: list[tuple[float, str]] = []
     for i, d in enumerate(distances):
         if d == min_distance:
-            out.append((i, string_list[i]))
+            s = string_list[i]
+            s_mapped = map_string.get(s, s)
+            out.append((i, s_mapped))
 
     return out
 

{fastled-1.2.55.dist-info → fastled-1.2.57.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.2.55
+Version: 1.2.57
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -19,8 +19,9 @@ Requires-Dist: disklru>=2.0.1
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: rapidfuzz>=3.10.1
 Requires-Dist: progress>=1.6
-Requires-Dist: Flask>=3.0.0
-Requires-Dist: livereload
+Requires-Dist: fastapi>=0.115.12
+Requires-Dist: uvicorn>=0.34.2
+Requires-Dist: pywebview>=5.4
 Dynamic: home-page
 Dynamic: license-file
 Dynamic: maintainer
@@ -295,8 +296,8 @@ A: `delay()` will block `loop()` which blocks the main thread of the browser. Th
 Q: How can I get the compiled size of my FastLED sketch smaller?
 A: A big chunk of space is being used by unnecessary javascript `emscripten` bundling. The wasm_compiler_settings.py file in the FastLED repo can tweak this.
 
-# Revisions
 
+# Revisions
   * 1.2.31 - Bunch of fixes and ease of use while compiling code in the repo.
   * 1.2.22 - Prefer to use `live-server` from npm. If npm exists on the system then do a background install of `live-server` for next run.
   * 1.2.20 - Fixed up path issue for web browser launch for hot reload.
@@ -382,3 +383,15 @@ A: A big chunk of space is being used by unnecessary javascript `emscripten` bun
   * 1.0.2 - Small bug with new installs.
   * 1.0.1 - Re-use is no longer the default, due to problems.
   * 1.0.0 - Initial release.
+
+
+# TODO
+  * `live-server --https --cert=localhost.pem --key=localhost-key.pem --port=5500`
+  * `live-server --port=8416 --host=localhost . --https --cert=C:/Users/niteris/dev/fastled-wasm/src/fastled/assets/localhost-key.pem --key=C:/Users/niteris/dev/fastled-wasm/src/fastled/assets/localhost.pem --no-browser`
+
+
+
+  live-server --https --port=8416 --host=localhost .  --cert=C:/Users/niteris/dev/fastled-wasm/src/fastled/assets/localhost-key.pem --key=C:/Users/niteris/dev/fastled-wasm/src/fastled/assets/localhost.pem --no-browser
+
+
+  live-server --https --cert=src/fastled/assets/localhost.pem --key=src/fastled/assets/localhost-key.pem --port=5500

{fastled-1.2.55.dist-info → fastled-1.2.57.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fastled/__init__.py,sha256=6kRImRI2Oc4dHucIY5jBajNGE5d3zpUrExS-ZTRUcow,6734
+fastled/__init__.py,sha256=TQuJVAWhfzDR6ewPqYml0-qv9yV7urg0rd51MWlv84U,6734
 fastled/app.py,sha256=Ozn7OJ0rz3CEHsJKMhFLxV7TisRKo4DuFpVhrf5FQNw,3944
 fastled/cli.py,sha256=FjVr31ht0UPlAcmX-84NwfAGMQHTkrCe4o744jCAxiw,375
 fastled/cli_test.py,sha256=qJB9yLRFR3OwOwdIWSQ0fQsWLnA37v5pDccufiP_hTs,512
@@ -6,31 +6,36 @@ fastled/client_server.py,sha256=Pr_b_406XpB6QLrlRMV3mwM82x25s1bIGFU0O0XA3yk,1493
 fastled/compile_server.py,sha256=ul3eiZNX2wwmInooo3PJC3_kNpdejYVDIo94G3sV9HQ,2941
 fastled/compile_server_impl.py,sha256=xhC7WBlIfvghgpxAP8VwBeM13NuTA99cI47prODW-IU,9927
 fastled/docker_manager.py,sha256=VVyfl4HNsSB95nlENuccZFR0qL3Y0ZJgPCFyHKa9A14,31459
-fastled/filewatcher.py,sha256=40XZ2euBg5ZMHsjv8obxHApVAUE5ztUEd7FTGqtgsMc,9826
+fastled/filewatcher.py,sha256=3qS3L7zMQhFuVrkeGn1djsB_cB6x_E2YGJmmQWVAU_w,10033
 fastled/interactive_srcs.py,sha256=F5nHdJc60xsnmOtnKhngE9JytqGn56PmYw_MVSIX1ac,138
 fastled/keyboard.py,sha256=UTAsqCn1UMYnB8YDzENiLTj4GeL45tYfEcO7_5fLFEg,3556
+fastled/keyz.py,sha256=WjfZHtZHEB8wNh1YYZGYwjx1jQV-6wwhCbYn4Zp7xs4,938
 fastled/live_client.py,sha256=MDauol0mxtXggV1Pv9ahC0Jjg_4wnnV6FjGEtdd9cxU,2763
-fastled/open_browser.py,sha256=KX2h9PUaPsKcwZ84i01DrXOnNpvaKLpB63u5kzcnEKQ,4342
-fastled/open_browser2.py,sha256=jUgN81bEYX-sr0zKTVJkwj9tXEVq7aZTxGUP_ShyCbs,3614
+fastled/open_browser.py,sha256=ls3nJBh61iV95Lq4n0zVhmtQ_xgXjpa5bMVOPRM5ldI,3988
+fastled/open_browser2.py,sha256=LT4EDAmOjusZfO1zTs3LyPFY6k3KjLsR4M3HVgJbnAY,2667
 fastled/parse_args.py,sha256=xgjxirQVX3FQxHZNVJtQQxTOeSJRQdGUNQ7W33Y880Y,8051
 fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
 fastled/project_init.py,sha256=OCIqpGmRMHNQtlXMTfX1x4Sou5WZgJtBNqPhnXbFFLI,4113
 fastled/select_sketch_directory.py,sha256=TZdCjl1D7YMKjodMTvDRurPcpAmN3x0TcJxffER2NfM,1314
-fastled/settings.py,sha256=Gr_KewMhBHTnlPYesHkbN_A3sEkjdVTh1pkNpkZwZrk,468
+fastled/server_fastapi.py,sha256=BLWERhxXcNxKk7Ub7eLRL1qgXBIgQw24-Zv5vek2X7A,1478
+fastled/server_fastapi_cli.py,sha256=i-Paq59dFpl-RV1xb7DycTHuDjaMhAo7u_WdVaSUDTY,1347
+fastled/settings.py,sha256=URgM6ZPlQYF-0ZTEhQCX8isLR6CbmYGwhDX4uXbh-ZI,468
 fastled/sketch.py,sha256=tHckjDj8P6BI_LWzUFM071a9qcqPs-r-qFWIe50P5Xw,3391
 fastled/spinner.py,sha256=VHxmvB92P0Z_zYxRajb5HiNmkHHvZ5dG7hKtZltzpcs,867
-fastled/string_diff.py,sha256=UR1oRhg9lsPzAG4bn_MwJMCn0evP5AigkBiwLiI9fgA,1354
+fastled/string_diff.py,sha256=9Q_36W0j7HvTnvfemdq9Ldi5RznGj0duX0Y3sZmVwJI,1730
 fastled/types.py,sha256=ZFqHxYIGSeQb9FiImA5KDXZLhmmVSjOrIQDduwxmCZw,4494
 fastled/util.py,sha256=t4M3NFMhnCzfYbLvIyJi0RdFssZqbTN_vVIaej1WV-U,265
 fastled/web_compile.py,sha256=H2Tm5kMBaRjqdHqxv7L3-xSeYNHi0k0P-XM0Cn9esOo,10360
 fastled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
+fastled/assets/localhost-key.pem,sha256=Q-CNO_UoOd8fFNN4ljcnqwUeCMhzTplRjLO2x0pYRlU,1704
+fastled/assets/localhost.pem,sha256=QTwUtTwjYWbm9m3pHW2IlK2nFZJ8b0pppxPjhgVZqQo,1619
 fastled/site/build.py,sha256=pjsaeHQQh_Zdh1g5Q78lYlUT7UPDFuNgW5YZkpsPxWc,14436
 fastled/site/examples.py,sha256=s6vj2zJc6BfKlnbwXr1QWY1mzuDBMt6j5MEBOWjO_U8,155
 fastled/test/can_run_local_docker_tests.py,sha256=LEuUbHctRhNNFWcvnz2kEGmjDJeXO4c3kNpizm3yVJs,400
 fastled/test/examples.py,sha256=GfaHeY1E8izBl6ZqDVjz--RHLyVR4NRnQ5pBesCFJFY,1673
-fastled-1.2.55.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-fastled-1.2.55.dist-info/METADATA,sha256=fLJj2AsQnGgflwpxrBCI-Ktt047LhKacc_1mc2Kr0sU,21668
-fastled-1.2.55.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-fastled-1.2.55.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
-fastled-1.2.55.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
-fastled-1.2.55.dist-info/RECORD,,
+fastled-1.2.57.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.2.57.dist-info/METADATA,sha256=HzmflBOGtZA3gUqFVXKHMQ0NZmJN8nYFDjUvMgH49Uo,22374
+fastled-1.2.57.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+fastled-1.2.57.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.2.57.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
+fastled-1.2.57.dist-info/RECORD,,

{fastled-1.2.55.dist-info → fastled-1.2.57.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any