fastled 1.2.60__py3-none-any.whl → 1.2.62__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.60"
+__version__ = "1.2.62"
 
 DOCKER_FILE = (
     "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/Dockerfile"

fastled/open_browser.py

@@ -14,10 +14,9 @@ SSL_CONFIG = get_ssl_config()
 # print(f"SSL Config: {SSL_CONFIG.certfile}, {SSL_CONFIG.keyfile}")
 
 
-def open_http_server_subprocess(
+def _open_http_server_subprocess(
     fastled_js: Path,
     port: int,
-    open_browser: bool,
 ) -> None:
     print("\n################################################################")
     print(f"# Opening browser to {fastled_js} on port {port}")
@@ -27,13 +26,11 @@ def open_http_server_subprocess(
         cmd = [
             PYTHON_EXE,
             "-m",
-            "fastled.open_browser2",
+            "fastled.server_start",
             str(fastled_js),
             "--port",
             str(port),
         ]
-        if open_browser:
-            cmd.append("--open-browser")
         # Pass SSL flags if available
         if SSL_CONFIG.certfile and SSL_CONFIG.keyfile:
             cmd.extend(
@@ -52,7 +49,7 @@ def open_http_server_subprocess(
         subprocess.run(
             cmd,
             stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
+            # stderr=subprocess.DEVNULL,
         )  # type ignore
     except KeyboardInterrupt:
         print("Exiting from server...")
@@ -111,21 +108,21 @@ def open_browser_process(
         port = find_free_port(DEFAULT_PORT)
 
     proc = Process(
-        target=open_http_server_subprocess,
-        args=(fastled_js, port, open_browser),
+        target=_open_http_server_subprocess,
+        args=(fastled_js, port),
         daemon=True,
     )
     proc.start()
     wait_for_server(port)
-    # if open_browser:
-    #     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,
-    #     )
+    if open_browser:
+        print(f"Opening browser to http://localhost:{port}")
+        import webbrowser
+
+        webbrowser.open(
+            url=f"http://localhost:{port}",
+            new=1,
+            autoraise=True,
+        )
     return proc
 
 

fastled/project_init.py

@@ -1,129 +1,129 @@
-import _thread
-import threading
-import time
-import zipfile
-from pathlib import Path
-
-import httpx
-
-from fastled.settings import DEFAULT_URL
-from fastled.spinner import Spinner
-
-DEFAULT_EXAMPLE = "wasm"
-
-
-def get_examples(host: str | None = None) -> list[str]:
-    host = host or DEFAULT_URL
-    url_info = f"{host}/info"
-    response = httpx.get(url_info, timeout=4)
-    response.raise_for_status()
-    examples: list[str] = response.json()["examples"]
-    return sorted(examples)
-
-
-def _prompt_for_example() -> str:
-    examples = get_examples()
-    while True:
-        print("Available examples:")
-        for i, example in enumerate(examples):
-            print(f"  [{i+1}]: {example}")
-        answer = input("Enter the example number or name: ").strip()
-        if answer.isdigit():
-            example_num = int(answer) - 1
-            if example_num < 0 or example_num >= len(examples):
-                print("Invalid example number")
-                continue
-            return examples[example_num]
-        elif answer in examples:
-            return answer
-
-
-class DownloadThread(threading.Thread):
-    def __init__(self, url: str, json: str):
-        super().__init__(daemon=True)
-        self.url = url
-        self.json = json
-        self.bytes_downloaded = 0
-        self.content: bytes | None = None
-        self.error: Exception | None = None
-        self.success = False
-
-    def run(self) -> None:
-        timeout = httpx.Timeout(5.0, connect=5.0, read=120.0, write=30.0)
-        try:
-            with httpx.Client(timeout=timeout) as client:
-                with client.stream("POST", self.url, json=self.json) as response:
-                    response.raise_for_status()
-                    content = b""
-                    for chunk in response.iter_bytes():
-                        content += chunk
-                        self.bytes_downloaded += len(chunk)
-                    self.content = content
-                    self.success = True
-        except KeyboardInterrupt:
-            self.error = RuntimeError("Download cancelled")
-            _thread.interrupt_main()
-        except Exception as e:
-            self.error = e
-
-
-def project_init(
-    example: str | None = "PROMPT",  # prompt for example
-    outputdir: Path | None = None,
-    host: str | None = None,
-) -> Path:
-    """
-    Initialize a new FastLED project.
-    """
-    host = host or DEFAULT_URL
-    outputdir = Path(outputdir) if outputdir is not None else Path("fastled")
-    outputdir.mkdir(exist_ok=True, parents=True)
-    if example == "PROMPT" or example is None:
-        try:
-            example = _prompt_for_example()
-        except httpx.HTTPStatusError:
-            print(
-                f"Failed to fetch examples, using default example '{DEFAULT_EXAMPLE}'"
-            )
-            example = DEFAULT_EXAMPLE
-    assert example is not None
-    endpoint_url = f"{host}/project/init"
-    json = example
-    print(f"Initializing project with example '{example}', url={endpoint_url}")
-
-    # Start download thread
-    download_thread = DownloadThread(endpoint_url, json)
-    # spinner = Spinner("Downloading project...")
-    with Spinner(f"Downloading project {example}..."):
-        download_thread.start()
-        while download_thread.is_alive():
-            time.sleep(0.1)
-
-    print()  # New line after progress
-    download_thread.join()
-
-    # Check for errors
-    if not download_thread.success:
-        assert download_thread.error is not None
-        raise download_thread.error
-
-    content = download_thread.content
-    assert content is not None
-    tmpzip = outputdir / "fastled.zip"
-    outputdir.mkdir(exist_ok=True)
-    tmpzip.write_bytes(content)
-    with zipfile.ZipFile(tmpzip, "r") as zip_ref:
-        zip_ref.extractall(outputdir)
-    tmpzip.unlink()
-    out = outputdir / example
-    print(f"Project initialized at {out}")
-    assert out.exists()
-    return out
-
-
-def unit_test() -> None:
-    project_init()
-
-
-if __name__ == "__main__":
-    unit_test()
+import _thread
+import threading
+import time
+import zipfile
+from pathlib import Path
+
+import httpx
+
+from fastled.settings import DEFAULT_URL
+from fastled.spinner import Spinner
+
+DEFAULT_EXAMPLE = "wasm"
+
+
+def get_examples(host: str | None = None) -> list[str]:
+    host = host or DEFAULT_URL
+    url_info = f"{host}/info"
+    response = httpx.get(url_info, timeout=4)
+    response.raise_for_status()
+    examples: list[str] = response.json()["examples"]
+    return sorted(examples)
+
+
+def _prompt_for_example() -> str:
+    examples = get_examples()
+    while True:
+        print("Available examples:")
+        for i, example in enumerate(examples):
+            print(f"  [{i+1}]: {example}")
+        answer = input("Enter the example number or name: ").strip()
+        if answer.isdigit():
+            example_num = int(answer) - 1
+            if example_num < 0 or example_num >= len(examples):
+                print("Invalid example number")
+                continue
+            return examples[example_num]
+        elif answer in examples:
+            return answer
+
+
+class DownloadThread(threading.Thread):
+    def __init__(self, url: str, json: str):
+        super().__init__(daemon=True)
+        self.url = url
+        self.json = json
+        self.bytes_downloaded = 0
+        self.content: bytes | None = None
+        self.error: Exception | None = None
+        self.success = False
+
+    def run(self) -> None:
+        timeout = httpx.Timeout(5.0, connect=5.0, read=120.0, write=30.0)
+        try:
+            with httpx.Client(timeout=timeout) as client:
+                with client.stream("POST", self.url, json=self.json) as response:
+                    response.raise_for_status()
+                    content = b""
+                    for chunk in response.iter_bytes():
+                        content += chunk
+                        self.bytes_downloaded += len(chunk)
+                    self.content = content
+                    self.success = True
+        except KeyboardInterrupt:
+            self.error = RuntimeError("Download cancelled")
+            _thread.interrupt_main()
+        except Exception as e:
+            self.error = e
+
+
+def project_init(
+    example: str | None = "PROMPT",  # prompt for example
+    outputdir: Path | None = None,
+    host: str | None = None,
+) -> Path:
+    """
+    Initialize a new FastLED project.
+    """
+    host = host or DEFAULT_URL
+    outputdir = Path(outputdir) if outputdir is not None else Path("fastled")
+    outputdir.mkdir(exist_ok=True, parents=True)
+    if example == "PROMPT" or example is None:
+        try:
+            example = _prompt_for_example()
+        except httpx.HTTPStatusError:
+            print(
+                f"Failed to fetch examples, using default example '{DEFAULT_EXAMPLE}'"
+            )
+            example = DEFAULT_EXAMPLE
+    assert example is not None
+    endpoint_url = f"{host}/project/init"
+    json = example
+    print(f"Initializing project with example '{example}', url={endpoint_url}")
+
+    # Start download thread
+    download_thread = DownloadThread(endpoint_url, json)
+    # spinner = Spinner("Downloading project...")
+    with Spinner(f"Downloading project {example}..."):
+        download_thread.start()
+        while download_thread.is_alive():
+            time.sleep(0.1)
+
+    print()  # New line after progress
+    download_thread.join()
+
+    # Check for errors
+    if not download_thread.success:
+        assert download_thread.error is not None
+        raise download_thread.error
+
+    content = download_thread.content
+    assert content is not None
+    tmpzip = outputdir / "fastled.zip"
+    outputdir.mkdir(exist_ok=True)
+    tmpzip.write_bytes(content)
+    with zipfile.ZipFile(tmpzip, "r") as zip_ref:
+        zip_ref.extractall(outputdir)
+    tmpzip.unlink()
+    out = outputdir / example
+    print(f"Project initialized at {out}")
+    assert out.exists()
+    return out
+
+
+def unit_test() -> None:
+    project_init()
+
+
+if __name__ == "__main__":
+    unit_test()

fastled/server_fastapi_cli.py

@@ -33,13 +33,13 @@ def _run_fastapi_server(
         host="127.0.0.1",
         port=port,
         reload=True,
-        reload_includes=["index.html"],
+        # reload_includes=["index.html"],
         ssl_certfile=certfile,
         ssl_keyfile=keyfile,
     )
 
 
-def run_fastapi_server_proces(
+def run_fastapi_server_process(
     port: int,
     cwd: Path | None = None,
     certfile: Path | None = None,
@@ -57,5 +57,5 @@ def run_fastapi_server_proces(
 
 if __name__ == "__main__":
     # Example usage
-    proc = run_fastapi_server_proces(port=8000)
+    proc = run_fastapi_server_process(port=8000)
     proc.join()

fastled/server_flask.py

@@ -0,0 +1,128 @@
+import argparse
+from multiprocessing import Process
+from pathlib import Path
+
+from livereload import Server
+
+
+def _run_flask_server(fastled_js: Path, port: int) -> None:
+    """Run Flask server with live reload in a subprocess"""
+    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(port: int, cwd: Path) -> None:
+    """Run the Flask server."""
+    try:
+        _run_flask_server(cwd, port)
+        import warnings
+
+        warnings.warn("Flask server has stopped")
+    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"
+    )
+    parser.add_argument(
+        "fastled_js", type=Path, help="Path to the fastled_js directory"
+    )
+    parser.add_argument(
+        "--port",
+        "-p",
+        type=int,
+        required=True,
+        help="Port to run the server on (default: %(default)s)",
+    )
+    return parser.parse_args()
+
+
+def run_flask_server_process(
+    port: int,
+    cwd: Path | None = None,
+    certfile: Path | None = None,  # type: ignore[unused-argument]
+    keyfile: Path | None = None,  # type: ignore[unused-argument]
+) -> Process:
+    """Run the FastAPI server in a separate process."""
+    cwd = cwd or Path(".")
+    process = Process(
+        target=run,
+        args=(port, cwd),
+    )
+    process.start()
+    return process
+
+
+def main() -> None:
+    """Main function."""
+    args = parse_args()
+    run(args.fastled_js, args.port)
+
+
+if __name__ == "__main__":
+    main()

fastled/{open_browser2.py → server_start.py}

@@ -2,7 +2,13 @@ import argparse
 import importlib.resources as pkg_resources
 from pathlib import Path
 
-from .server_fastapi_cli import run_fastapi_server_proces
+from fastled.server_fastapi_cli import run_fastapi_server_process
+from fastled.server_flask import run_flask_server_process
+
+if True:
+    run_server_process = run_flask_server_process
+else:
+    run_server_process = run_fastapi_server_process
 
 
 def get_asset_path(filename: str) -> Path | None:
@@ -16,28 +22,9 @@ def get_asset_path(filename: str) -> Path | None:
         return None
 
 
-def _open_browser(url: str) -> None:
-    # import webview
-
-    # print("\n##################################################")
-    # print(f"# Opening browser to {url}")
-    # print("##################################################\n")
-
-    # webview.create_window("FastLED", url)
-    # webview.start()
-    import webbrowser
-
-    webbrowser.open(url, new=1, autoraise=True)
-    while True:
-        import time
-
-        time.sleep(1)
-
-
 def run(
     path: Path,
     port: int,
-    open_browser: bool,
     certfile: Path | None = None,
     keyfile: Path | None = None,
 ) -> None:
@@ -49,10 +36,8 @@ def run(
         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}/")
+    # run_fastapi_server_process(port=port, path=path, certfile=certfile, keyfile=keyfile)
+    proc = run_server_process(port=port, cwd=path)
     try:
         proc.join()
     except KeyboardInterrupt:
@@ -81,16 +66,11 @@ def parse_args() -> argparse.Namespace:
     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:
     args = parse_args()
-    open_browser: bool = args.open_browser
     fastled_js: Path = args.fastled_js
     port: int = args.port
     cert: Path | None = args.cert
@@ -98,7 +78,6 @@ def main() -> None:
     run(
         path=fastled_js,
         port=port,
-        open_browser=open_browser,
         certfile=cert,
         keyfile=key,
     )