fastled 1.0.8__py2.py3-none-any.whl

fastled/paths.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+PROJECT_ROOT = HERE.parent.parent

fastled/sketch.py

@@ -0,0 +1,55 @@
+import os
+from pathlib import Path
+
+
+def get_sketch_files(directory: Path) -> list[Path]:
+    files: list[Path] = []
+    for root, dirs, filenames in os.walk(directory):
+        # ignore hidden directories
+        dirs[:] = [d for d in dirs if not d.startswith(".")]
+        # ignore fastled_js directory
+        dirs[:] = [d for d in dirs if "fastled_js" not in d]
+        # ignore hidden files
+        filenames = [f for f in filenames if not f.startswith(".")]
+        for filename in filenames:
+            if "platformio.ini" in filename:
+                continue
+            files.append(Path(root) / filename)
+    return files
+
+
+def looks_like_fastled_repo(directory: Path) -> bool:
+    libprops = directory / "library.properties"
+    if not libprops.exists():
+        return False
+    txt = libprops.read_text(encoding="utf-8", errors="ignore")
+    return "FastLED" in txt
+
+
+def _lots_and_lots_of_files(directory: Path) -> bool:
+    return len(get_sketch_files(directory)) > 100
+
+
+def looks_like_sketch_directory(directory: Path) -> bool:
+    if looks_like_fastled_repo(directory):
+        print("Directory looks like the FastLED repo")
+        return False
+
+    if _lots_and_lots_of_files(directory):
+        print("Too many files in the directory, bailing out")
+        return False
+
+    # walk the path and if there are over 30 files, return False
+    # at the root of the directory there should either be an ino file or a src directory
+    # or some cpp files
+    # if there is a platformio.ini file, return True
+    ino_file_at_root = list(directory.glob("*.ino"))
+    if ino_file_at_root:
+        return True
+    cpp_file_at_root = list(directory.glob("*.cpp"))
+    if cpp_file_at_root:
+        return True
+    platformini_file = list(directory.glob("platformio.ini"))
+    if platformini_file:
+        return True
+    return False

fastled/web_compile.py

@@ -0,0 +1,227 @@
+import io
+import shutil
+import tempfile
+import zipfile
+from concurrent.futures import ThreadPoolExecutor, 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
+
+DEFAULT_HOST = "https://fastled.onrender.com"
+ENDPOINT_COMPILED_WASM = "compile/wasm"
+_TIMEOUT = 60 * 4  # 2 mins timeout
+_AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
+
+_THREAD_POOL = ThreadPoolExecutor(max_workers=8)
+
+
+@dataclass
+class TestConnectionResult:
+    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}"
+
+
+_CONNECTION_ERROR_MAP: dict[str, TestConnectionResult] = {}
+
+
+def _test_connection(host: str, use_ipv4: bool) -> TestConnectionResult:
+    key = f"{host}-{use_ipv4}"
+    maybe_result: TestConnectionResult | None = _CONNECTION_ERROR_MAP.get(key)
+    if maybe_result is not None:
+        return maybe_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 = TestConnectionResult(
+                host, test_response.status_code == 200, use_ipv4
+            )
+            _CONNECTION_ERROR_MAP[key] = result
+    except Exception:
+        result = TestConnectionResult(host, False, use_ipv4)
+        _CONNECTION_ERROR_MAP[key] = result
+    return result
+
+
+def zip_files(directory: Path) -> bytes | 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
+        zip_buffer = io.BytesIO()
+        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)
+                zip_file.write(file_path, str(Path("wasm") / relative_path))
+        return zip_buffer.getvalue()
+    except Exception as e:
+        return e
+
+
+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)
+    print("Compiling on", host)
+    auth_token = auth_token or _AUTH_TOKEN
+
+    if not directory.exists():
+        raise FileNotFoundError(f"Directory not found: {directory}")
+
+    zip_bytes = zip_files(directory)
+    if isinstance(zip_bytes, Exception):
+        return WebCompileResult(
+            success=False, stdout=str(zip_bytes), hash_value=None, zip_bytes=b""
+        )
+    archive_size = len(zip_bytes)
+    print(f"Web compiling on {host}...")
+    try:
+
+        files = {"file": ("wasm.zip", zip_bytes, "application/x-zip-compressed")}
+        urls = [host]
+        domain = host.split("://")[-1]
+        if ":" not in domain:
+            urls.append(f"{host}:{SERVER_PORT}")
+        test_connection_result: TestConnectionResult | None = None
+
+        futures: list = []
+        ip_versions = [True, False] if "localhost" not in host else [True]
+        for ipv4 in ip_versions:
+            for url in urls:
+                f = _THREAD_POOL.submit(_test_connection, url, ipv4)
+                futures.append(f)
+
+        succeeded = False
+        for future in as_completed(futures):
+            result: TestConnectionResult = future.result()
+
+            if result.success:
+                print(f"Connection successful to {result.host}")
+                succeeded = True
+                # host = test_url
+                test_connection_result = result
+                break
+            else:
+                print(f"Ignoring {result.host} due to connection failure")
+
+        if not succeeded:
+            print("Connection failed to all endpoints")
+            return WebCompileResult(
+                success=False,
+                stdout="Connection failed",
+                hash_value=None,
+                zip_bytes=b"",
+            )
+        assert test_connection_result is not None
+        ipv4_stmt = "IPv4" if test_connection_result.ipv4 else "IPv6"
+        transport = (
+            httpx.HTTPTransport(local_address="0.0.0.0")
+            if test_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"{test_connection_result.host}/{ENDPOINT_COMPILED_WASM}"
+            print(f"Compiling on {url} via {ipv4_stmt}. Zip size: {archive_size} bytes")
+            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")
+
+                # 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""
+        )

fastled-1.0.8.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 zackees
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastled-1.0.8.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.1
+Name: fastled
+Version: 1.0.8
+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.8 - Program now knows it's own version which will be displayed with help file. Use `--version` to get it directly.
+  * 1.1.7 - Sketch cache re-enabled, but selectively invalidated on cpp/h updates. Cleaned up deprecated args. Fixed double thread running for containers that was causing slowdown.
+  * 1.1.6 - Use the fast src volume map allow quick updates to fastled when developing on the source code.
+  * 1.1.5 - Filter out hidden files and directories from being included in the sketch archive sent to the compiler.
+  * 1.1.4 - Fix regression introduced by testing out ipv4/ipv6 connections from a thread pool.
+  * 1.1.3 - Live editing of *.h and *.cpp files is now possible. Sketch cache will be disabled in this mode.
+  * 1.1.2 - `--server` will now volume map fastled src directory if it detects this. This was also implemented on the docker side.
+  * 1.1.1 - `--interactive` is now supported to debug the container. Volume maps and better compatibilty with ipv4/v6 by concurrent connection finding.
+  * 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.0.8.dist-info/RECORD

@@ -0,0 +1,19 @@
+fastled/__init__.py,sha256=jl2oKYN0FYQt0z1v-aHeEqO9DGZIIYf3gUPuYhUrgKE,63
+fastled/app.py,sha256=S6hDqYw8gLOOGpXr7pBFJ4opuqY0LhqrJiymajY6FWU,12875
+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=8avG0mAjdjU0w1ej4LiKVGLgkHi8dZxT48TLuGecj7A,9451
+fastled/docker_manager.py,sha256=WcOKa3EpIPAjICPfTL87CUYuAmX9KYT6L_Hcqbj95eE,9028
+fastled/filewatcher.py,sha256=SHKx9Dnt4EJiT-iPYakdPZBRIL1gsJGN9tY8FJW2myU,5079
+fastled/open_browser.py,sha256=-VhpGmydwLCcXmrDD2esMEdJPZYcoX2Mt73eb88Nna0,1392
+fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
+fastled/sketch.py,sha256=KhhPFqlFVlBk8YrzFy7-ioe7zEzecgrVLhyFbLpBp7k,1845
+fastled/web_compile.py,sha256=vVQ68lldGo3CaQcYGf3lh9yU6K_A3zP1gNJ29pi5J-E,7857
+fastled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
+fastled-1.0.8.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.0.8.dist-info/METADATA,sha256=CimvtLSLl7xSQbSxb67Kdk0dRHTkvV-eDfulpjNvr0A,6316
+fastled-1.0.8.dist-info/WHEEL,sha256=0VNUDWQJzfRahYI3neAhz2UVbRCtztpN5dPHAGvmGXc,109
+fastled-1.0.8.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.0.8.dist-info/top_level.txt,sha256=xfG6Z_ol9V5YmBROkZq2QTRwjbS2ouCUxaTJsOwfkOo,14
+fastled-1.0.8.dist-info/RECORD,,

fastled-1.0.8.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.5.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

fastled-1.0.8.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+fastled = fastled.cli:main
+fastled-wasm = fastled.cli:main
+fled = fastled.cli:main

fastled-1.0.8.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+cache
+fastled