fastled 1.0.15__py2.py3-none-any.whl → 1.1.0__py2.py3-none-any.whl

fastled/web_compile.py

@@ -1,291 +1,173 @@
-import io
-import json
-import os
-import shutil
-import tempfile
-import zipfile
-from concurrent.futures import Future, ProcessPoolExecutor, as_completed
-from dataclasses import dataclass
-from pathlib import Path
-
-import httpx
-
-from fastled.build_mode import BuildMode
-from fastled.compile_server import SERVER_PORT
-from fastled.sketch import get_sketch_files
-from fastled.util import hash_file
-
-DEFAULT_HOST = "https://fastled.onrender.com"
-ENDPOINT_COMPILED_WASM = "compile/wasm"
-_TIMEOUT = 60 * 4  # 2 mins timeout
-_AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
-ENABLE_EMBEDDED_DATA = True
-_EXECUTOR = ProcessPoolExecutor(max_workers=8)
-
-
-@dataclass
-class ConnectionResult:
-    host: str
-    success: bool
-    ipv4: bool
-
-
-@dataclass
-class WebCompileResult:
-    success: bool
-    stdout: str
-    hash_value: str | None
-    zip_bytes: bytes
-
-    def __bool__(self) -> bool:
-        return self.success
-
-
-def _sanitize_host(host: str) -> str:
-    if host.startswith("http"):
-        return host
-    is_local_host = "localhost" in host or "127.0.0.1" in host or "0.0.0.0" in host
-    use_https = not is_local_host
-    if use_https:
-        return host if host.startswith("https://") else f"https://{host}"
-    return host if host.startswith("http://") else f"http://{host}"
-
-
-def _test_connection(host: str, use_ipv4: bool) -> ConnectionResult:
-    # Function static cache
-    connection_cache = _test_connection.__dict__.setdefault("_CONNECTION_CACHE", {})
-    key = f"{host}_{use_ipv4}"
-    cached_result = connection_cache.get(key)
-    if cached_result is not None:
-        return cached_result
-    transport = httpx.HTTPTransport(local_address="0.0.0.0") if use_ipv4 else None
-    try:
-        with httpx.Client(
-            timeout=_TIMEOUT,
-            transport=transport,
-        ) as test_client:
-            test_response = test_client.get(
-                f"{host}/healthz", timeout=3, follow_redirects=True
-            )
-            result = ConnectionResult(host, test_response.status_code == 200, use_ipv4)
-    except Exception:
-        result = ConnectionResult(host, False, use_ipv4)
-    connection_cache[key] = result
-    return result
-
-
-def _file_info(file_path: Path) -> str:
-    hash_txt = hash_file(file_path)
-    file_size = file_path.stat().st_size
-    json_str = json.dumps({"hash": hash_txt, "size": file_size})
-    return json_str
-
-
-@dataclass
-class ZipResult:
-    zip_bytes: bytes
-    zip_embedded_bytes: bytes | None
-    success: bool
-    error: str | None
-
-
-def zip_files(directory: Path, build_mode: BuildMode) -> ZipResult | Exception:
-    print("Zipping files...")
-    try:
-        files = get_sketch_files(directory)
-        if not files:
-            raise FileNotFoundError(f"No files found in {directory}")
-        for f in files:
-            print(f"Adding file: {f}")
-        # Create in-memory zip file
-        has_embedded_zip = False
-        zip_embedded_buffer = io.BytesIO()
-        zip_buffer = io.BytesIO()
-        with zipfile.ZipFile(
-            zip_embedded_buffer, "w", zipfile.ZIP_DEFLATED, compresslevel=9
-        ) as emebedded_zip_file:
-            with zipfile.ZipFile(
-                zip_buffer, "w", zipfile.ZIP_DEFLATED, compresslevel=9
-            ) as zip_file:
-                for file_path in files:
-                    relative_path = file_path.relative_to(directory)
-                    achive_path = str(Path("wasm") / relative_path)
-                    if str(relative_path).startswith("data") and ENABLE_EMBEDDED_DATA:
-                        _file_info_str = _file_info(file_path)
-                        zip_file.writestr(
-                            achive_path + ".embedded.json", _file_info_str
-                        )
-                        emebedded_zip_file.write(file_path, relative_path)
-                        has_embedded_zip = True
-                    else:
-                        zip_file.write(file_path, achive_path)
-                # write build mode into the file as build.txt so that sketches are fingerprinted
-                # based on the build mode. Otherwise the same sketch with different build modes
-                # will have the same fingerprint.
-                zip_file.writestr(
-                    str(Path("wasm") / "build_mode.txt"), build_mode.value
-                )
-        result = ZipResult(
-            zip_bytes=zip_buffer.getvalue(),
-            zip_embedded_bytes=(
-                zip_embedded_buffer.getvalue() if has_embedded_zip else None
-            ),
-            success=True,
-            error=None,
-        )
-        return result
-    except Exception as e:
-        return e
-
-
-def find_good_connection(
-    urls: list[str], filter_out_bad=True, use_ipv6: bool = True
-) -> ConnectionResult | None:
-    futures: list[Future] = []
-    for url in urls:
-        f = _EXECUTOR.submit(_test_connection, url, use_ipv4=True)
-        futures.append(f)
-        if use_ipv6:
-            f_v6 = _EXECUTOR.submit(_test_connection, url, use_ipv4=False)
-            futures.append(f_v6)
-
-    try:
-        # Return first successful result
-        for future in as_completed(futures):
-            result: ConnectionResult = future.result()
-            if result.success or not filter_out_bad:
-                return result
-    finally:
-        # Cancel any remaining futures
-        for future in futures:
-            future.cancel()
-    return None
-
-
-def web_compile(
-    directory: Path,
-    host: str | None = None,
-    auth_token: str | None = None,
-    build_mode: BuildMode | None = None,
-    profile: bool = False,
-) -> WebCompileResult:
-    host = _sanitize_host(host or DEFAULT_HOST)
-    build_mode = build_mode or BuildMode.QUICK
-    print("Compiling on", host)
-    auth_token = auth_token or _AUTH_TOKEN
-    if not directory.exists():
-        raise FileNotFoundError(f"Directory not found: {directory}")
-    zip_result = zip_files(directory, build_mode=build_mode)
-    if isinstance(zip_result, Exception):
-        return WebCompileResult(
-            success=False, stdout=str(zip_result), hash_value=None, zip_bytes=b""
-        )
-    zip_bytes = zip_result.zip_bytes
-    archive_size = len(zip_bytes)
-    print(f"Web compiling on {host}...")
-    try:
-        urls = [host]
-        domain = host.split("://")[-1]
-        if ":" not in domain:
-            urls.append(f"{host}:{SERVER_PORT}")
-
-        connection_result = find_good_connection(urls)
-        if connection_result is None:
-            print("Connection failed to all endpoints")
-            return WebCompileResult(
-                success=False,
-                stdout="Connection failed",
-                hash_value=None,
-                zip_bytes=b"",
-            )
-
-        ipv4_stmt = "IPv4" if connection_result.ipv4 else "IPv6"
-        transport = (
-            httpx.HTTPTransport(local_address="0.0.0.0")
-            if connection_result.ipv4
-            else None
-        )
-        with httpx.Client(
-            transport=transport,
-            timeout=_TIMEOUT,
-        ) as client:
-            headers = {
-                "accept": "application/json",
-                "authorization": auth_token,
-                "build": (
-                    build_mode.value.lower()
-                    if build_mode
-                    else BuildMode.QUICK.value.lower()
-                ),
-                "profile": "true" if profile else "false",
-            }
-
-            url = f"{connection_result.host}/{ENDPOINT_COMPILED_WASM}"
-            print(f"Compiling on {url} via {ipv4_stmt}. Zip size: {archive_size} bytes")
-            files = {"file": ("wasm.zip", zip_bytes, "application/x-zip-compressed")}
-            response = client.post(
-                url,
-                follow_redirects=True,
-                files=files,
-                headers=headers,
-                timeout=_TIMEOUT,
-            )
-
-            if response.status_code != 200:
-                json_response = response.json()
-                detail = json_response.get("detail", "Could not compile")
-                return WebCompileResult(
-                    success=False, stdout=detail, hash_value=None, zip_bytes=b""
-                )
-
-            print(f"Response status code: {response}")
-            # Create a temporary directory to extract the zip
-            with tempfile.TemporaryDirectory() as extract_dir:
-                extract_path = Path(extract_dir)
-
-                # Write the response content to a temporary zip file
-                temp_zip = extract_path / "response.zip"
-                temp_zip.write_bytes(response.content)
-
-                # Extract the zip
-                shutil.unpack_archive(temp_zip, extract_path, "zip")
-
-                if zip_result.zip_embedded_bytes:
-                    # extract the embedded bytes, which were not sent to the server
-                    temp_zip.write_bytes(zip_result.zip_embedded_bytes)
-                    shutil.unpack_archive(temp_zip, extract_path, "zip")
-
-                # we don't need the temp zip anymore
-                temp_zip.unlink()
-
-                # Read stdout from out.txt if it exists
-                stdout_file = extract_path / "out.txt"
-                hash_file = extract_path / "hash.txt"
-                stdout = stdout_file.read_text() if stdout_file.exists() else ""
-                hash_value = hash_file.read_text() if hash_file.exists() else None
-
-                # now rezip the extracted files since we added the embedded json files
-                out_buffer = io.BytesIO()
-                with zipfile.ZipFile(
-                    out_buffer, "w", zipfile.ZIP_DEFLATED, compresslevel=9
-                ) as out_zip:
-                    for root, _, _files in os.walk(extract_path):
-                        for file in _files:
-                            file_path = Path(root) / file
-                            relative_path = file_path.relative_to(extract_path)
-                            out_zip.write(file_path, relative_path)
-
-                return WebCompileResult(
-                    success=True,
-                    stdout=stdout,
-                    hash_value=hash_value,
-                    zip_bytes=out_buffer.getvalue(),
-                )
-    except KeyboardInterrupt:
-        print("Keyboard interrupt")
-        raise
-    except httpx.HTTPError as e:
-        print(f"Error: {e}")
-        return WebCompileResult(
-            success=False, stdout=str(e), hash_value=None, zip_bytes=b""
-        )
+import shutil
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+
+from fastled.build_mode import BuildMode
+
+DEFAULT_HOST = "https://fastled.onrender.com"
+ENDPOINT_COMPILED_WASM = "compile/wasm"
+_TIMEOUT = 60 * 4  # 2 mins timeout
+_AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
+
+
+@dataclass
+class WebCompileResult:
+    success: bool
+    stdout: str
+    hash_value: str | None
+    zip_bytes: bytes
+
+    def __bool__(self) -> bool:
+        return self.success
+
+
+def _sanitize_host(host: str) -> str:
+    if host.startswith("http"):
+        return host
+    is_local_host = "localhost" in host or "127.0.0.1" in host or "0.0.0.0" in host
+    use_https = not is_local_host
+    if use_https:
+        return host if host.startswith("https://") else f"https://{host}"
+    return host if host.startswith("http://") else f"http://{host}"
+
+
+_CONNECTION_ERROR_MAP: dict[str, bool] = {}
+
+
+def web_compile(
+    directory: Path,
+    host: str | None = None,
+    auth_token: str | None = None,
+    build_mode: BuildMode | None = None,
+    profile: bool = False,
+) -> WebCompileResult:
+    host = _sanitize_host(host or DEFAULT_HOST)
+    auth_token = auth_token or _AUTH_TOKEN
+    # zip up the files
+    print("Zipping files...")
+
+    # Create a temporary zip file
+    with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp_zip:
+        # Create temporary directory for organizing files
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create wasm subdirectory
+            wasm_dir = Path(temp_dir) / "wasm"
+
+            # Copy all files from source to wasm subdirectory, excluding fastled_js
+            def ignore_fastled_js(dir: str, files: list[str]) -> list[str]:
+                if "fastled_js" in dir:
+                    return files
+                if dir.startswith("."):
+                    return files
+                return []
+
+            shutil.copytree(directory, wasm_dir, ignore=ignore_fastled_js)
+            # Create zip archive from the temp directory
+            shutil.make_archive(tmp_zip.name[:-4], "zip", temp_dir)
+
+    print(f"Web compiling on {host}...")
+
+    try:
+        with open(tmp_zip.name, "rb") as zip_file:
+            files = {"file": ("wasm.zip", zip_file, "application/x-zip-compressed")}
+
+            tested = host in _CONNECTION_ERROR_MAP
+            if not tested:
+                test_url = f"{host}/healthz"
+                print(f"Testing connection to {test_url}")
+                timeout = 10
+                with httpx.Client(
+                    transport=httpx.HTTPTransport(local_address="0.0.0.0"),
+                    timeout=timeout,
+                ) as test_client:
+                    test_response = test_client.get(test_url, timeout=timeout)
+                    if test_response.status_code != 200:
+                        print(f"Connection to {test_url} failed")
+                        _CONNECTION_ERROR_MAP[host] = True
+                        return WebCompileResult(
+                            success=False,
+                            stdout="Connection failed",
+                            hash_value=None,
+                            zip_bytes=b"",
+                        )
+                    _CONNECTION_ERROR_MAP[host] = False
+
+            ok = not _CONNECTION_ERROR_MAP[host]
+            if not ok:
+                return WebCompileResult(
+                    success=False,
+                    stdout="Connection failed",
+                    hash_value=None,
+                    zip_bytes=b"",
+                )
+            print(f"Connection to {host} successful")
+            with httpx.Client(
+                transport=httpx.HTTPTransport(local_address="0.0.0.0"),  # forces IPv4
+                timeout=_TIMEOUT,
+            ) as client:
+                url = f"{host}/{ENDPOINT_COMPILED_WASM}"
+                headers = {
+                    "accept": "application/json",
+                    "authorization": auth_token,
+                    "build": (
+                        build_mode.value.lower()
+                        if build_mode
+                        else BuildMode.QUICK.value.lower()
+                    ),
+                    "profile": "true" if profile else "false",
+                }
+                print(f"Compiling on {url}")
+                response = client.post(
+                    url,
+                    files=files,
+                    headers=headers,
+                    timeout=_TIMEOUT,
+                )
+
+                if response.status_code != 200:
+                    json_response = response.json()
+                    detail = json_response.get("detail", "Could not compile")
+                    return WebCompileResult(
+                        success=False, stdout=detail, hash_value=None, zip_bytes=b""
+                    )
+
+                print(f"Response status code: {response}")
+                # Create a temporary directory to extract the zip
+                with tempfile.TemporaryDirectory() as extract_dir:
+                    extract_path = Path(extract_dir)
+
+                    # Write the response content to a temporary zip file
+                    temp_zip = extract_path / "response.zip"
+                    temp_zip.write_bytes(response.content)
+
+                    # Extract the zip
+                    shutil.unpack_archive(temp_zip, extract_path, "zip")
+
+                    # Read stdout from out.txt if it exists
+                    stdout_file = extract_path / "out.txt"
+                    hash_file = extract_path / "hash.txt"
+                    stdout = stdout_file.read_text() if stdout_file.exists() else ""
+                    hash_value = hash_file.read_text() if hash_file.exists() else None
+
+                    return WebCompileResult(
+                        success=True,
+                        stdout=stdout,
+                        hash_value=hash_value,
+                        zip_bytes=response.content,
+                    )
+    except KeyboardInterrupt:
+        print("Keyboard interrupt")
+        raise
+    except httpx.HTTPError as e:
+        print(f"Error: {e}")
+        return WebCompileResult(
+            success=False, stdout=str(e), hash_value=None, zip_bytes=b""
+        )
+    finally:
+        try:
+            Path(tmp_zip.name).unlink()
+        except PermissionError:
+            print("Warning: Could not delete temporary zip file")

fastled-1.1.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: fastled
+Version: 1.1.0
+Summary: FastLED Wasm Compiler
+Home-page: https://github.com/zackees/fastled-wasm
+Maintainer: Zachary Vorhies
+License: BSD 3-Clause License
+Keywords: template-python-cmd
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: docker
+Requires-Dist: httpx
+Requires-Dist: watchdog
+Requires-Dist: livereload
+Requires-Dist: download
+Requires-Dist: filelock
+
+# FastLED wasm compiler
+
+Compiles an Arduino/Platformio sketch into a wasm binary that can be run directly in the web browser.
+
+[![Linting](https://github.com/zackees/fastled-wasm/actions/workflows/lint.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/lint.yml)
+[![Build and Push Multi Docker Image](https://github.com/zackees/fastled-wasm/actions/workflows/build_multi_docker_image.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/build_multi_docker_image.yml)
+[![MacOS_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_macos.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_macos.yml)
+[![Ubuntu_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_ubuntu.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_ubuntu.yml)
+[![Win_Tests](https://github.com/zackees/fastled-wasm/actions/workflows/test_win.yml/badge.svg)](https://github.com/zackees/fastled-wasm/actions/workflows/test_win.yml)
+
+
+
+# About
+
+This python app will compile your FastLED style sketches into html/js/wasm output that runs directly in the browser.
+
+Compile times are extremely fast - I've seen as low as 5 seconds but 8-15 seconds is typical.
+
+This works on Windows/Linux/Mac(arm/x64).
+
+Docker is required.
+
+https://github.com/user-attachments/assets/64ae0e6c-5f8b-4830-ab87-dcc25bc61218
+
+# Demo
+
+https://zackees.github.io/fastled-wasm/
+
+
+
+# Install
+
+```bash
+pip install fastled-wasm
+```
+
+**Note that you may need to install x86 docker emulation on Mac-m1 and later, as this is an x86 only image at the prsent.**
+
+# Use
+
+Change to the directory where the sketch lives and run
+
+```bash
+cd <SKETCH-DIRECTORY>
+fastled-wasm
+```
+
+Or if you don't have docker then use our web compiler
+
+```bash
+cd <SKETCH-DIRECTORY>
+fastled-wasm --web
+```
+
+After compilation a web browser windows will pop up.
+
+# Hot reload by default
+
+Once launched, the compiler will remain open, listening to changes and recompiling as necessary and hot-reloading the sketch into the current browser.
+
+This style of development should be familiar to those doing web development.
+
+# Data
+
+If you want to embed data, then do so in the `data/` directory at the project root. The files will appear in the `data/` director of any spawned FileSystem or SDCard.
+
+
+### About the compilation.
+
+Pre-processing is done to your source files. A fake Arduino.h will be inserted into your source files that will
+provide shims for most of the common api points.
+
+
+# Revisions
+
+  * 1.1.0 - Use `fastled` as the command for the wasm compiler.
+  * 1.0.17 - Pulls updates when necessary. Removed dependency on keyring.
+  * 1.0.16 - `fastled-wasm` package name has been changed to `fled`
+  * 1.0.15 - `fled` is an alias of `fastled-wasm` and will eventually replace it. `--web-host` was folded into `--web`, which if unspecified will attempt to run a local docker server and fallback to the cloud server if that fails. Specifying `--web` with no arguments will default to the cloud server while an argument (like `localhost`) will cause it to bind to that already running server for compilation.
+  * 1.0.14 - For non significant changes (comments, whitespace) in C++/ino/*.h files, compilation is skipped. This significantly reduces load on the server and prevents unnecessary local client browser refreshes.
+  * 1.0.13 - Increase speed of local compiles by running the server version of the compiler so it can keep it's cache and not have to pay docker startup costs because now it's a persistant server until exit.
+  * 1.0.12 - Added suppport for compile modes. Pass in `--release`, `--quick`, `--debug` for different compile options. We also support `--profile` to profile the build process.
+  * 1.0.11 - `--web` compile will automatically be enabled if the local build using docker fails.
+  * 1.0.10 - Watching files is now available for `--web`
+  * 1.0.9 - Enabled web compile. Access it with `--web` or `--web-host`
+  * 1.0.8 - Allow more than one fastled-wasm browser instances to co-exist by searching for unused ports after 8081.
+  * 1.0.7 - Docker multi image build implemented, tool now points to new docker image compile.
+  * 1.0.6 - Removed `--no-open` and `--watch`, `--watch` is now assumed unless `--just-compile` is used.
+  * 1.0.5 - Implemented `--update` to update the compiler image from the docker registry.
+  * 1.0.4 - Implemented `--watch` which will watch for changes and then re-launch the compilation step.
+  * 1.0.3 - Integrated `live-server` to launch when available.
+  * 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.

fastled-1.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+fastled/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastled/app.py,sha256=N4a-XXteQMTmODxRmEuicUuXKyfP9OS6rGxT36aVAWs,11380
+fastled/build_mode.py,sha256=joMwsV4K1y_LijT4gEAcjx69RZBoe_KmFmHZdPYbL_4,631
+fastled/check_cpp_syntax.py,sha256=YxRJm7cFPv4bdhL1v_KOkBz8RL86ihayoJYvclr69ms,1024
+fastled/cli.py,sha256=CNR_pQR0sNVPNuv8e_nmm-0PI8sU-eUBUgnWgWkzW9c,237
+fastled/compile_server.py,sha256=_tpHpOgxcizgb9Lis8RVTDsLKLtCaaH3upVH65z0XhA,7994
+fastled/docker_manager.py,sha256=eEc12bmQEER7xf-7ehfYJgQua9cDB1IlLVuuw_9eflI,8934
+fastled/filewatcher.py,sha256=SHKx9Dnt4EJiT-iPYakdPZBRIL1gsJGN9tY8FJW2myU,5079
+fastled/open_browser.py,sha256=-VhpGmydwLCcXmrDD2esMEdJPZYcoX2Mt73eb88Nna0,1392
+fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
+fastled/web_compile.py,sha256=xHy4ndEy5Xr5-WCINFrgvPgfk7XPm5_MhveiOElJKb0,6372
+fastled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
+fastled-1.1.0.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.1.0.dist-info/METADATA,sha256=C5bl7UjYlsgO2a-Xf6qi9-Dwcg6ctrYWlhZMB86GSSs,5294
+fastled-1.1.0.dist-info/WHEEL,sha256=0VNUDWQJzfRahYI3neAhz2UVbRCtztpN5dPHAGvmGXc,109
+fastled-1.1.0.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.1.0.dist-info/top_level.txt,sha256=xfG6Z_ol9V5YmBROkZq2QTRwjbS2ouCUxaTJsOwfkOo,14
+fastled-1.1.0.dist-info/RECORD,,