fastled 1.2.80__tar.gz → 1.2.82__tar.gz

{fastled-1.2.80 → fastled-1.2.82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.2.80
+Version: 1.2.82
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -13,15 +13,11 @@ License-File: LICENSE
 Requires-Dist: docker>=7.1.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: watchdog>=6.0.0
-Requires-Dist: download>=0.3.5
 Requires-Dist: filelock>=3.16.1
 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: fastapi>=0.115.12
-Requires-Dist: uvicorn>=0.34.2
-Requires-Dist: pywebview>=5.4
 Requires-Dist: watchfiles>=1.0.5
 Requires-Dist: Flask>=3.0.0
 Requires-Dist: livereload

{fastled-1.2.80 → fastled-1.2.82}/compiler/compile.py

@@ -86,7 +86,7 @@ def copy_files(src_dir: Path, js_src: Path) -> None:
             print(f"Copying file: {item}")
             shutil.copy2(item, js_src / item.name)
     else:
-        warnings.warn("No files found in the mapped directory.")
+        warnings.warn(f"No files found in the mapped directory: {src_dir.absolute()}")
 
 
 def _banner(msg: str) -> str:

{fastled-1.2.80 → fastled-1.2.82}/compiler/server.py

@@ -598,6 +598,40 @@ def project_init_example(
     )
 
 
+@app.get("/sourcefiles/{filepath:path}")
+def source_file(filepath: str) -> FileResponse:
+    """Get the source file from the server."""
+    print(f"Endpoint accessed: /sourcefiles/{filepath}")
+    if ".." in filepath:
+        raise HTTPException(status_code=400, detail="Invalid file path.")
+    full_path = Path(FASTLED_SRC / filepath)
+    if not full_path.exists():
+        raise HTTPException(status_code=404, detail="File not found.")
+    if not full_path.is_file():
+        raise HTTPException(status_code=400, detail="Not a file.")
+    if not full_path.is_relative_to(FASTLED_SRC):
+        raise HTTPException(status_code=400, detail="Invalid file path.")
+
+    suffix = full_path.suffix
+    if suffix in [".h", ".cpp"]:
+        media_type = "text/plain"
+    elif suffix == ".html":
+        media_type = "text/html"
+    elif suffix == ".js":
+        media_type = "application/javascript"
+    elif suffix == ".css":
+        media_type = "text/css"
+    else:
+        media_type = "application/octet-stream"
+
+    fr = FileResponse(
+        path=full_path,
+        media_type=media_type,
+        filename=filepath,
+    )
+    return fr
+
+
 @app.get("/static/{file_path:path}")
 async def static_files(file_path: str) -> Response:
     """Serve static files."""

{fastled-1.2.80 → fastled-1.2.82}/docker-compose.yml

@@ -4,6 +4,7 @@ services:
     build:
       context: .
     ports:
-      - "80:80"
+      - "8234:80"
     environment:
       - ENVIRONMENT=dev
+    image: niteris/fastled-wasm:latest

{fastled-1.2.80 → fastled-1.2.82}/lint

@@ -1,6 +1,12 @@
 #!/bin/bash
 set -e
 
+# if venv doesn't exist, invoke ./install
+if [ ! -d ".venv" ]; then
+    echo "No venv present, so installing..."
+    ./install
+fi
+
 . ./activate
 
 echo Running ruff src compiler

{fastled-1.2.80 → fastled-1.2.82}/pyproject.toml

@@ -14,7 +14,6 @@ dependencies = [
     "docker>=7.1.0",
     "httpx>=0.28.1",
     "watchdog>=6.0.0",
-    "download>=0.3.5",
     ########## Begin Docker Manager Dependencies
     "filelock>=3.16.1",
     "disklru>=2.0.1",
@@ -22,9 +21,6 @@ dependencies = [
     "rapidfuzz>=3.10.1",
     "progress>=1.6",
     ########## End Docker Manager Dependencies
-    "fastapi>=0.115.12",
-    "uvicorn>=0.34.2",
-    "pywebview>=5.4",
     "watchfiles>=1.0.5",
     "Flask>=3.0.0",
     "livereload",

{fastled-1.2.80 → fastled-1.2.82}/src/fastled/__init__.py

@@ -9,12 +9,12 @@ from .compile_server import CompileServer
 from .live_client import LiveClient
 from .settings import DOCKER_FILE, IMAGE_NAME
 from .site.build import build
-from .types import BuildMode, CompileResult, CompileServerError
+from .types import BuildMode, CompileResult, CompileServerError, FileResponse
 
 # 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.80"
+__version__ = "1.2.82"
 
 
 class Api:
@@ -65,6 +65,9 @@ class Api:
         keep_running=True,
         build_mode=BuildMode.QUICK,
         profile=False,
+        http_port: (
+            int | None
+        ) = None,  # None means auto select a free port. -1 means no server.
     ) -> LiveClient:
         return LiveClient(
             sketch_directory=sketch_directory,
@@ -75,6 +78,7 @@ class Api:
             keep_running=keep_running,
             build_mode=build_mode,
             profile=profile,
+            http_port=http_port,
         )
 
     @staticmethod
@@ -197,12 +201,12 @@ class Test:
         compile_server_port: int | None = None,
         open_browser: bool = True,
     ) -> Process:
-        from fastled.open_browser import open_browser_process
+        from fastled.open_browser import spawn_http_server
 
         compile_server_port = compile_server_port or -1
         if isinstance(directory, str):
             directory = Path(directory)
-        proc: Process = open_browser_process(
+        proc: Process = spawn_http_server(
             directory,
             port=port,
             compile_server_port=compile_server_port,
@@ -218,5 +222,6 @@ __all__ = [
     "CompileResult",
     "CompileServerError",
     "BuildMode",
+    "FileResponse",
     "DOCKER_FILE",
 ]

{fastled-1.2.80 → fastled-1.2.82}/src/fastled/client_server.py

@@ -2,6 +2,7 @@ import shutil
 import tempfile
 import threading
 import time
+import warnings
 from multiprocessing import Process
 from pathlib import Path
 
@@ -9,7 +10,7 @@ from fastled.compile_server import CompileServer
 from fastled.docker_manager import DockerManager
 from fastled.filewatcher import DebouncedFileWatcherProcess, FileWatcherProcess
 from fastled.keyboard import SpaceBarWatcher
-from fastled.open_browser import open_browser_process
+from fastled.open_browser import spawn_http_server
 from fastled.parse_args import Args
 from fastled.settings import DEFAULT_URL
 from fastled.sketch import looks_like_sketch_directory
@@ -165,6 +166,45 @@ def _try_start_server_or_get_url(
             return (DEFAULT_URL, None)
 
 
+def _try_make_compile_server() -> CompileServer | None:
+    if not DockerManager.is_docker_installed():
+        return None
+    try:
+        print(
+            "\nNo host specified, but Docker is installed, attempting to start a compile server using Docker."
+        )
+        from fastled.util import find_free_port
+
+        free_port = find_free_port(start_port=9723, end_port=9743)
+        if free_port is None:
+            return None
+        compile_server = CompileServer(auto_updates=False)
+        print("Waiting for the local compiler to start...")
+        if not compile_server.ping():
+            print("Failed to start local compiler.")
+            raise CompileServerError("Failed to start local compiler.")
+        return compile_server
+    except KeyboardInterrupt:
+        import _thread
+
+        _thread.interrupt_main()
+        raise
+    except Exception as e:
+        warnings.warn(f"Error starting local compile server: {e}")
+        return None
+
+
+def _is_local_host(host: str) -> bool:
+    return (
+        host.startswith("http://localhost")
+        or host.startswith("http://127.0.0.1")
+        or host.startswith("http://0.0.0.0")
+        or host.startswith("http://[::]")
+        or host.startswith("http://[::1]")
+        or host.startswith("http://[::ffff:127.0.0.1]")
+    )
+
+
 def run_client(
     directory: Path,
     host: str | CompileServer | None,
@@ -173,14 +213,24 @@ def run_client(
     build_mode: BuildMode = BuildMode.QUICK,
     profile: bool = False,
     shutdown: threading.Event | None = None,
+    http_port: (
+        int | None
+    ) = None,  # None means auto select a free port, http_port < 0 means no server.
 ) -> int:
+    compile_server: CompileServer | None = None
+
+    if host is None:
+        # attempt to start a compile server if docker is installed.
+        compile_server = _try_make_compile_server()
+        if compile_server is None:
+            host = DEFAULT_URL
+    elif isinstance(host, CompileServer):
+        # if the host is a compile server, use that
+        compile_server = host
 
-    compile_server: CompileServer | None = (
-        host if isinstance(host, CompileServer) else None
-    )
     shutdown = shutdown or threading.Event()
 
-    def get_url() -> str:
+    def get_url(host=host, compile_server=compile_server) -> str:
         if compile_server is not None:
             return compile_server.url()
         if isinstance(host, str):
@@ -196,6 +246,11 @@ def run_client(
     if parsed_url.port is not None:
         port = parsed_url.port
     else:
+        if _is_local_host(url):
+            raise ValueError(
+                "Cannot use local host without a port. Please specify a port."
+            )
+        # Assume default port for www
         port = 80
 
     try:
@@ -221,10 +276,20 @@ def run_client(
         if not result.success:
             print("\nCompilation failed.")
 
-        browser_proc: Process | None = None
-        if open_web_browser:
-            browser_proc = open_browser_process(
-                directory / "fastled_js", compile_server_port=port
+        use_http_server = http_port is None or http_port >= 0
+        if not use_http_server and open_web_browser:
+            warnings.warn(
+                f"Warning: --http-port={http_port} specified but open_web_browser is False, ignoring --http-port."
+            )
+            use_http_server = False
+
+        http_proc: Process | None = None
+        if use_http_server:
+            http_proc = spawn_http_server(
+                directory / "fastled_js",
+                port=http_port,
+                compile_server_port=port,
+                open_browser=open_web_browser,
             )
         else:
             print("\nCompilation successful.")
@@ -234,8 +299,8 @@ def run_client(
             return 0
 
         if not keep_running or shutdown.is_set():
-            if browser_proc:
-                browser_proc.kill()
+            if http_proc:
+                http_proc.kill()
             return 0 if result.success else 1
     except KeyboardInterrupt:
         print("\nExiting from main")
@@ -346,8 +411,8 @@ def run_client(
         debounced_sketch_watcher.stop()
         if compile_server:
             compile_server.stop()
-        if browser_proc:
-            browser_proc.kill()
+        if http_proc:
+            http_proc.kill()
 
 
 def run_client_server(args: Args) -> int:

{fastled-1.2.80 → fastled-1.2.82}/src/fastled/compile_server.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from fastled.types import BuildMode, CompileResult, Platform
+from fastled.types import BuildMode, CompileResult, FileResponse, Platform
 
 
 class CompileServer:
@@ -53,6 +53,10 @@ class CompileServer:
 
         project_init(example=example, outputdir=outputdir)
 
+    def fetch_source_file(self, filepath: str) -> FileResponse | Exception:
+        """Get the source file from the server."""
+        return self.impl.fetch_source_file(filepath)
+
     @property
     def name(self) -> str:
         return self.impl.container_name

{fastled-1.2.80 → fastled-1.2.82}/src/fastled/compile_server_impl.py

@@ -17,7 +17,8 @@ from fastled.docker_manager import (
 )
 from fastled.settings import DEFAULT_CONTAINER_NAME, IMAGE_NAME, SERVER_PORT
 from fastled.sketch import looks_like_fastled_repo
-from fastled.types import BuildMode, CompileResult, CompileServerError
+from fastled.types import BuildMode, CompileResult, CompileServerError, FileResponse
+from fastled.util import port_is_free
 
 SERVER_OPTIONS = [
     "--allow-shutdown",  # Allow the server to be shut down without a force kill.
@@ -36,32 +37,6 @@ def _try_get_fastled_src(path: Path) -> Path | None:
     return None
 
 
-def _port_is_free(port: int) -> bool:
-    """Check if a port is free."""
-    import socket
-
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-        try:
-            _ = sock.bind(("localhost", port)) and sock.bind(("0.0.0.0", port))
-            return True
-        except OSError:
-            return False
-
-
-def _find_free_port() -> int:
-    """Find a free port on the system."""
-
-    start_port = 49152
-    tries = 10
-
-    for port in range(start_port, start_port + tries):
-        if _port_is_free(port):
-            return port
-    raise RuntimeError(
-        f"No free port found in the range {start_port}-{start_port + tries - 1}"
-    )
-
-
 class CompileServerImpl:
     def __init__(
         self,
@@ -204,6 +179,29 @@ class CompileServerImpl:
                 return False
         return False
 
+    def fetch_source_file(self, filepath: str) -> FileResponse | Exception:
+        """Get the source file from the server."""
+        if not self._port:
+            raise RuntimeError("Server has not been started yet")
+        try:
+            httpx_client = httpx.Client()
+            url = f"http://localhost:{self._port}/sourcefiles/{filepath}"
+            response = httpx_client.get(url, follow_redirects=True)
+            if response.status_code == 200:
+                content = response.text
+                mimetype: str = response.headers.get("Content-Type", "text/plain")
+                return FileResponse(
+                    content=content,
+                    mimetype=mimetype,
+                    filename=filepath,
+                )
+            else:
+                return CompileServerError(
+                    f"Error fetching file {filepath}: {response.status_code}"
+                )
+        except httpx.RequestError as e:
+            return CompileServerError(f"Error fetching file {filepath}: {e}")
+
     def _start(self) -> int:
         print("Compiling server starting")
 
@@ -227,7 +225,7 @@ class CompileServerImpl:
             image_name=IMAGE_NAME, tag="latest", upgrade=upgrade
         )
         DISK_CACHE.put("last-update", now_str)
-        CLIENT_PORT = 80  # TODO: Don't use port 80.
+        INTERNAL_DOCKER_PORT = 80
 
         print("Docker image now validated")
         port = SERVER_PORT
@@ -239,7 +237,7 @@ class CompileServerImpl:
             print("Disabling port forwarding in interactive mode")
             ports = {}
         else:
-            ports = {CLIENT_PORT: port}
+            ports = {INTERNAL_DOCKER_PORT: port}
         volumes = []
         if self.fastled_src_dir:
             print(
@@ -318,11 +316,11 @@ class CompileServerImpl:
             print("Compile server starting")
             return port
         else:
-            client_port_mapped = CLIENT_PORT in ports
-            port_is_free = _port_is_free(CLIENT_PORT)
-            if client_port_mapped and port_is_free:
+            client_port_mapped = INTERNAL_DOCKER_PORT in ports
+            free_port = port_is_free(INTERNAL_DOCKER_PORT)
+            if client_port_mapped and free_port:
                 warnings.warn(
-                    f"Can't expose port {CLIENT_PORT}, disabling port forwarding in interactive mode"
+                    f"Can't expose port {INTERNAL_DOCKER_PORT}, disabling port forwarding in interactive mode"
                 )
                 ports = {}
             self.docker.run_container_interactive(

{fastled-1.2.80 → fastled-1.2.82}/src/fastled/live_client.py

@@ -16,6 +16,9 @@ class LiveClient:
         auto_start: bool = True,
         auto_updates: bool = True,
         open_web_browser: bool = True,
+        http_port: (
+            int | None
+        ) = None,  # None means auto select a free port. -1 means no server.
         keep_running: bool = True,
         build_mode: BuildMode = BuildMode.QUICK,
         profile: bool = False,
@@ -23,6 +26,7 @@ class LiveClient:
         self.sketch_directory = sketch_directory
         self.host = host
         self.open_web_browser = open_web_browser
+        self.http_port = http_port
         self.keep_running = keep_running
         self.build_mode = build_mode
         self.profile = profile
@@ -47,6 +51,7 @@ class LiveClient:
             build_mode=self.build_mode,
             profile=self.profile,
             shutdown=self.shutdown,
+            http_port=self.http_port,
         )
         return rtn
 

{fastled-1.2.80 → fastled-1.2.82}/src/fastled/open_browser.py

@@ -1,51 +1,36 @@
-import subprocess
+import atexit
+import random
 import sys
 import time
+import weakref
 from multiprocessing import Process
 from pathlib import Path
 
-from fastled.keyz import get_ssl_config
+from fastled.server_flask import run_flask_in_thread
 
 DEFAULT_PORT = 8089  # different than live version.
 PYTHON_EXE = sys.executable
 
+# Use a weak reference set to track processes without preventing garbage collection
+_WEAK_CLEANUP_SET = weakref.WeakSet()
 
-# print(f"SSL Config: {SSL_CONFIG.certfile}, {SSL_CONFIG.keyfile}")
 
+def add_cleanup(proc: Process) -> None:
+    """Add a process to the cleanup list using weak references"""
+    _WEAK_CLEANUP_SET.add(proc)
 
-def _open_http_server_subprocess(
-    fastled_js: Path, port: int, compile_server_port: int
-) -> None:
-    print("\n################################################################")
-    print(f"# Opening browser to {fastled_js} on port {port}")
-    print("################################################################\n")
-    ssl = get_ssl_config()
-    try:
-        # Fallback to our Python server
-        cmd = [
-            PYTHON_EXE,
-            "-m",
-            "fastled.server_start",
-            str(fastled_js),
-            "--port",
-            str(port),
-            "--compile-server-port",
-            str(compile_server_port),
-        ]
-        # Pass SSL flags if available
-        if ssl:
-            raise NotImplementedError("SSL is not implemented yet")
-        print(f"Running server on port {port}.")
-        print(f"Command: {subprocess.list2cmdline(cmd)}")
-        # Suppress output
-        subprocess.run(
-            cmd,
-            stdout=subprocess.DEVNULL,
-            # stderr=subprocess.DEVNULL,
-        )  # type ignore
-    except KeyboardInterrupt:
-        print("Exiting from server...")
-        sys.exit(0)
+    # Register a cleanup function that checks if the process is still alive
+    def cleanup_if_alive():
+        if proc.is_alive():
+            try:
+                proc.terminate()
+                proc.join(timeout=1.0)
+                if proc.is_alive():
+                    proc.kill()
+            except Exception:
+                pass
+
+    atexit.register(cleanup_if_alive)
 
 
 def is_port_free(port: int) -> bool:
@@ -88,7 +73,7 @@ def wait_for_server(port: int, timeout: int = 10) -> None:
     raise TimeoutError("Could not connect to server")
 
 
-def open_browser_process(
+def spawn_http_server(
     fastled_js: Path,
     compile_server_port: int,
     port: int | None = None,
@@ -98,14 +83,26 @@ def open_browser_process(
     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)
+        offset = random.randint(0, 100)
+        port = find_free_port(DEFAULT_PORT + offset)
+
+    # port: int,
+    # cwd: Path,
+    # compile_server_port: int,
+    # certfile: Path | None = None,
+    # keyfile: Path | None = None,
 
     proc = Process(
-        target=_open_http_server_subprocess,
-        args=(fastled_js, port, compile_server_port),
+        target=run_flask_in_thread,
+        args=(port, fastled_js, compile_server_port),
         daemon=True,
     )
+    add_cleanup(proc)
     proc.start()
+
+    # Add to cleanup set with weak reference
+    add_cleanup(proc)
+
     wait_for_server(port)
     if open_browser:
         print(f"Opening browser to http://localhost:{port}")
@@ -136,5 +133,5 @@ if __name__ == "__main__":
     )
     args = parser.parse_args()
 
-    proc = open_browser_process(args.fastled_js, args.port, open_browser=True)
+    proc = spawn_http_server(args.fastled_js, args.port, open_browser=True)
     proc.join()

{fastled-1.2.80 → fastled-1.2.82}/src/fastled/server_flask.py

@@ -61,6 +61,32 @@ def _run_flask_server(
 
             return response
 
+        @app.route("/sourcefiles/<path:path>")
+        def serve_source_files(path):
+            """Proxy requests to /sourcefiles/* to the compile server"""
+            from flask import Response, request
+
+            # Forward the request to the compile server
+            target_url = f"http://localhost:{compile_server_port}/sourcefiles/{path}"
+
+            # Forward the request with the same method, headers, and body
+            resp = requests.request(
+                method=request.method,
+                url=target_url,
+                headers={key: value for key, value in request.headers if key != "Host"},
+                data=request.get_data(),
+                cookies=request.cookies,
+                allow_redirects=True,
+                stream=False,
+            )
+
+            # Create a Flask Response object from the requests response
+            response = Response(
+                resp.raw.read(), status=resp.status_code, headers=dict(resp.headers)
+            )
+
+            return response
+
         @app.route("/<path:path>")
         def serve_files(path):
             response = send_from_directory(fastled_js, path)
@@ -112,7 +138,7 @@ def _run_flask_server(
         _thread.interrupt_main()
 
 
-def run(
+def run_flask_in_thread(
     port: int,
     cwd: Path,
     compile_server_port: int,
@@ -169,7 +195,7 @@ def run_flask_server_process(
 ) -> Process:
     """Run the Flask server in a separate process."""
     process = Process(
-        target=run,
+        target=run_flask_in_thread,
         args=(port, cwd, compile_server_port, certfile, keyfile),
     )
     process.start()
@@ -179,7 +205,7 @@ def run_flask_server_process(
 def main() -> None:
     """Main function."""
     args = parse_args()
-    run(args.port, args.fastled_js, args.certfile, args.keyfile)
+    run_flask_in_thread(args.port, args.fastled_js, args.certfile, args.keyfile)
 
 
 if __name__ == "__main__":

fastled-1.2.82/src/fastled/server_start.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+from fastled.server_flask import run_flask_in_thread
+
+
+def start_server_in_thread(
+    port: int,
+    fastled_js: Path,
+    compile_server_port: int,
+    certfile: Path | None = None,
+    keyfile: Path | None = None,
+) -> None:
+    """Start the server in a separate thread."""
+
+    run_flask_in_thread(
+        port=port,
+        cwd=fastled_js,
+        compile_server_port=compile_server_port,
+        certfile=certfile,
+        keyfile=keyfile,
+    )

{fastled-1.2.80 → fastled-1.2.82}/src/fastled/types.py

@@ -151,3 +151,12 @@ class Platform(Enum):
             raise ValueError(
                 f"Platform must be one of {valid_modes}, got {platform_str}"
             )
+
+
+@dataclass
+class FileResponse:
+    """File response from the server."""
+
+    filename: str
+    content: str
+    mimetype: str