fastled 1.1.45__py3-none-any.whl

fastled/select_sketch_directory.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+from fastled.string_diff import string_diff_paths
+
+
+def select_sketch_directory(
+    sketch_directories: list[Path], cwd_is_fastled: bool
+) -> str | None:
+    if cwd_is_fastled:
+        exclude = ["src", "dev", "tests"]
+        for ex in exclude:
+            p = Path(ex)
+            if p in sketch_directories:
+                sketch_directories.remove(p)
+
+    if len(sketch_directories) == 1:
+        print(f"\nUsing sketch directory: {sketch_directories[0]}")
+        return str(sketch_directories[0])
+    elif len(sketch_directories) > 1:
+        print("\nMultiple Directories found, choose one:")
+        for i, sketch_dir in enumerate(sketch_directories):
+            print(f"  [{i+1}]: {sketch_dir}")
+        which = input("\nPlease specify a sketch directory: ").strip()
+        try:
+            index = int(which) - 1
+            return str(sketch_directories[index])
+        except (ValueError, IndexError):
+            inputs = [p for p in sketch_directories]
+            top_hits: list[tuple[float, Path]] = string_diff_paths(which, inputs)
+            if len(top_hits) == 1:
+                example = top_hits[0][1]
+                return str(example)
+            else:
+                return select_sketch_directory([p for _, p in top_hits], cwd_is_fastled)
+    return None

fastled/settings.py

@@ -0,0 +1,9 @@
+import os
+import platform
+
+MACHINE = platform.machine().lower()
+IS_ARM: bool = "arm" in MACHINE or "aarch64" in MACHINE
+PLATFORM_TAG: str = "-arm64" if IS_ARM else ""
+CONTAINER_NAME = f"fastled-wasm-compiler{PLATFORM_TAG}"
+DEFAULT_URL = str(os.environ.get("FASTLED_URL", "https://fastled.onrender.com"))
+SERVER_PORT = 9021

fastled/sketch.py

@@ -0,0 +1,97 @@
+import os
+from pathlib import Path
+
+_MAX_FILES_SEARCH_LIMIT = 10000
+
+
+def find_sketch_directories(directory: Path) -> list[Path]:
+    file_count = 0
+    sketch_directories: list[Path] = []
+    # search all the paths one level deep
+    for path in directory.iterdir():
+        if path.is_dir():
+            dir_name = path.name
+            if str(dir_name).startswith("."):
+                continue
+            file_count += 1
+            if file_count > _MAX_FILES_SEARCH_LIMIT:
+                print(
+                    f"More than {_MAX_FILES_SEARCH_LIMIT} files found. Stopping search."
+                )
+                break
+
+            if looks_like_sketch_directory(path, quick=True):
+                sketch_directories.append(path)
+            if dir_name.lower() == "examples":
+                for example in path.iterdir():
+                    if example.is_dir():
+                        if looks_like_sketch_directory(example, quick=True):
+                            sketch_directories.append(example)
+    # make relative to cwd
+    sketch_directories = [p.relative_to(directory) for p in sketch_directories]
+    return sketch_directories
+
+
+def get_sketch_files(directory: Path) -> list[Path]:
+    file_count = 0
+    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(".")]
+        outer_break = False
+        for filename in filenames:
+            if "platformio.ini" in filename:
+                continue
+            file_count += 1
+            if file_count > _MAX_FILES_SEARCH_LIMIT:
+                print(
+                    f"More than {_MAX_FILES_SEARCH_LIMIT} files found. Stopping search."
+                )
+                outer_break = True
+                break
+            files.append(Path(root) / filename)
+        if outer_break:
+            break
+
+    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, quick=False) -> bool:
+    if looks_like_fastled_repo(directory):
+        print("Directory looks like the FastLED repo")
+        return False
+
+    if not quick:
+        if _lots_and_lots_of_files(directory):
+            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/spinner.py

@@ -0,0 +1,34 @@
+import _thread
+import threading
+import time
+import warnings
+
+from progress.spinner import Spinner as SpinnerImpl
+
+
+class Spinner:
+    def __init__(self, message: str = ""):
+        self.spinner = SpinnerImpl(message)
+        self.event = threading.Event()
+        self.thread = threading.Thread(target=self._spin, daemon=True)
+        self.thread.start()
+
+    def _spin(self) -> None:
+        try:
+            while not self.event.is_set():
+                self.spinner.next()
+                time.sleep(0.1)
+        except KeyboardInterrupt:
+            _thread.interrupt_main()
+        except Exception as e:
+            warnings.warn(f"Spinner thread failed: {e}")
+
+    def stop(self) -> None:
+        self.event.set()
+        self.thread.join()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()

fastled/string_diff.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+from rapidfuzz import fuzz
+
+
+# Returns the min distance strings. If there is a tie, it returns
+# all the strings that have the same min distance.
+# Returns a tuple of index and string.
+def string_diff(
+    input_string: str, string_list: list[str], ignore_case=True
+) -> list[tuple[float, str]]:
+
+    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
+    # ]
+    distances: list[float] = []
+    for s in string_list:
+        dist = fuzz.token_sort_ratio(normalize(input_string), normalize(s))
+        distances.append(1.0 / (dist + 1.0))
+    min_distance = min(distances)
+    out: list[tuple[float, str]] = []
+    for i, d in enumerate(distances):
+        if d == min_distance:
+            out.append((i, string_list[i]))
+
+    return out
+
+
+def string_diff_paths(
+    input_string: str | Path, path_list: list[Path], ignore_case=True
+) -> list[tuple[float, Path]]:
+    string_list = [str(p) for p in path_list]
+    tmp = string_diff(str(input_string), string_list, ignore_case)
+    out: list[tuple[float, Path]] = []
+    for i, j in tmp:
+        p = Path(j)
+        out.append((i, p))
+    return out

fastled/test/examples.py

@@ -0,0 +1,31 @@
+from tempfile import TemporaryDirectory
+
+
+def test_examples(
+    examples: list[str] | None = None, host: str | None = None
+) -> dict[str, Exception]:
+    """Test the examples in the given directory."""
+    from fastled import Api
+
+    out: dict[str, Exception] = {}
+    examples = Api.get_examples() if examples is None else examples
+    with TemporaryDirectory() as tmpdir:
+        for example in examples:
+            print(f"Initializing example: {example}")
+            sketch_dir = Api.project_init(example, outputdir=tmpdir, host=host)
+            print(f"Project initialized at: {sketch_dir}")
+            print(f"Compiling example: {example}")
+            result = Api.web_compile(sketch_dir, host=host)
+            if not result.success:
+                out[example] = Exception(result.stdout)
+    return out
+
+
+def unit_test() -> None:
+    out = test_examples()
+    if out:
+        raise RuntimeError(f"Failed tests: {out}")
+
+
+if __name__ == "__main__":
+    unit_test()

fastled/types.py

@@ -0,0 +1,61 @@
+import argparse
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+
+@dataclass
+class CompileResult:
+    success: bool
+    stdout: str
+    hash_value: str | None
+    zip_bytes: bytes
+
+    def __bool__(self) -> bool:
+        return self.success
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.__dict__.copy()
+
+
+class CompileServerError(Exception):
+    """Error class for failing to instantiate CompileServer."""
+
+    pass
+
+
+class BuildMode(Enum):
+    DEBUG = "DEBUG"
+    QUICK = "QUICK"
+    RELEASE = "RELEASE"
+
+    @classmethod
+    def from_string(cls, mode_str: str) -> "BuildMode":
+        try:
+            return cls[mode_str.upper()]
+        except KeyError:
+            valid_modes = [mode.name for mode in cls]
+            raise ValueError(f"BUILD_MODE must be one of {valid_modes}, got {mode_str}")
+
+    @staticmethod
+    def from_args(args: argparse.Namespace) -> "BuildMode":
+        if args.debug:
+            return BuildMode.DEBUG
+        elif args.release:
+            return BuildMode.RELEASE
+        else:
+            return BuildMode.QUICK
+
+
+class Platform(Enum):
+    WASM = "WASM"
+
+    @classmethod
+    def from_string(cls, platform_str: str) -> "Platform":
+        try:
+            return cls[platform_str.upper()]
+        except KeyError:
+            valid_modes = [mode.name for mode in cls]
+            raise ValueError(
+                f"Platform must be one of {valid_modes}, got {platform_str}"
+            )

fastled/util.py

@@ -0,0 +1,10 @@
+import hashlib
+from pathlib import Path
+
+
+def hash_file(file_path: Path) -> str:
+    hasher = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(4096), b""):
+            hasher.update(chunk)
+    return hasher.hexdigest()

fastled/web_compile.py

@@ -0,0 +1,285 @@
+import _thread
+import io
+import json
+import os
+import shutil
+import tempfile
+import zipfile
+from concurrent.futures import Future, ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+
+from fastled.settings import SERVER_PORT
+from fastled.sketch import get_sketch_files
+from fastled.types import BuildMode, CompileResult
+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 = ThreadPoolExecutor(max_workers=8)
+
+
+@dataclass
+class ConnectionResult:
+    host: str
+    success: bool
+    ipv4: bool
+
+
+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
+    host = _sanitize_host(host)
+    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 KeyboardInterrupt:
+        _thread.interrupt_main()
+
+    except TimeoutError:
+        result = ConnectionResult(host, False, use_ipv4)
+    except Exception:
+        result = ConnectionResult(host, False, use_ipv4)
+    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 and "localhost" not in url:
+            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 | str,
+    host: str | None = None,
+    auth_token: str | None = None,
+    build_mode: BuildMode | None = None,
+    profile: bool = False,
+) -> CompileResult:
+    if isinstance(directory, str):
+        directory = Path(directory)
+    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 CompileResult(
+            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:
+        host = _sanitize_host(host)
+        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 CompileResult(
+                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 CompileResult(
+                    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 CompileResult(
+                    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 CompileResult(
+            success=False, stdout=str(e), hash_value=None, zip_bytes=b""
+        )

fastled-1.1.45.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.