fastled 1.2.23__py3-none-any.whl

fastled/site/build.py

@@ -0,0 +1,457 @@
+import argparse
+import subprocess
+from pathlib import Path
+from shutil import copytree, rmtree, which
+
+CSS_CONTENT = """
+/* CSS Reset & Variables */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+:root {
+    --color-background: #121212;
+    --color-surface: #252525;
+    --color-surface-transparent: rgba(30, 30, 30, 0.95);
+    --color-text: #E0E0E0;
+    --spacing-sm: 5px;
+    --spacing-md: 10px;
+    --spacing-lg: 15px;
+    --transition-speed: 0.3s;
+    --font-family: 'Roboto Condensed', sans-serif;
+    --nav-width: 250px;
+    --border-radius: 5px;
+}
+
+/* Base Styles */
+body {
+    background-color: var(--color-background);
+    color: var(--color-text);
+    margin: 0;
+    padding: 0;
+    font-family: var(--font-family);
+    min-height: 100vh;
+    display: grid;
+    grid-template-rows: 1fr;
+}
+
+/* Splash Screen */
+.splash-screen {
+    position: fixed;
+    inset: 0;
+    background-color: var(--color-background);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    z-index: 2000;
+    transition: opacity var(--transition-speed) ease-out;
+}
+
+.splash-text {
+    font-size: 14vw;
+    color: var(--color-text);
+    font-weight: 300;
+    font-family: var(--font-family);
+    opacity: 0;
+    transition: opacity var(--transition-speed) ease-in;
+}
+
+/* Layout */
+.content-wrapper {
+    position: relative;
+    width: 100%;
+    height: 100vh;
+    overflow-x: hidden;
+}
+
+/* Navigation */
+.nav-trigger {
+    position: fixed;
+    left: var(--spacing-md);
+    top: var(--spacing-md);
+    padding: 15px 30px;
+    z-index: 1001;
+    background-color: var(--color-surface);
+    border-radius: var(--border-radius);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    color: var(--color-text);
+    font-size: 24px;
+    transition: background-color var(--transition-speed) ease;
+}
+
+.nav-trigger:hover {
+    background-color: var(--color-surface-transparent);
+}
+
+.nav-trigger .fa-chevron-down {
+    margin-left: 10px;
+    transition: transform var(--transition-speed) ease;
+}
+
+.nav-pane.visible + .nav-trigger .fa-chevron-down {
+    transform: rotate(180deg);
+}
+
+.nav-pane {
+    position: fixed;
+    left: var(--spacing-md);
+    top: 60px;
+    width: var(--nav-width);
+    height: auto;
+    background-color: var(--color-surface-transparent);
+    border-radius: var(--border-radius);
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.5);
+    transform: translateY(-20px);
+    opacity: 0;
+    pointer-events: none;
+    transition: transform var(--transition-speed) ease,
+                opacity var(--transition-speed) ease;
+}
+
+.nav-pane.visible {
+    transform: translateY(0);
+    opacity: 1;
+    pointer-events: auto;
+}
+
+/* Main Content */
+.main-content {
+    width: 100%;
+    height: 100%;
+    padding: 0;
+    overflow: hidden;
+}
+
+#example-frame {
+    width: 100%;
+    height: 100%;
+    border: none;
+    background-color: var(--color-background);
+    overflow: auto;
+}
+
+/* Example Links */
+.example-link {
+    margin: var(--spacing-sm) var(--spacing-md);
+    padding: var(--spacing-lg) var(--spacing-md);
+    border-radius: var(--border-radius);
+    display: block;
+    text-decoration: none;
+    color: var(--color-text);
+    background-color: var(--color-surface);
+    transition: background-color var(--transition-speed) ease-in-out,
+                box-shadow var(--transition-speed) ease-in-out;
+    position: relative;
+    padding-right: 35px;
+}
+
+.example-link:hover {
+    background-color: var(--color-surface-transparent);
+    box-shadow: var(--shadow-hover, 0 0 10px rgba(255, 255, 255, 0.1));
+}
+
+.example-link:last-child {
+    margin-bottom: var(--spacing-md);
+}
+
+/* Accessibility */
+@media (prefers-reduced-motion: reduce) {
+    *, *::before, *::after {
+        animation-duration: 0.01ms !important;
+        animation-iteration-count: 1 !important;
+        transition-duration: 0.01ms !important;
+        scroll-behavior: auto !important;
+    }
+}
+"""
+
+INDEX_TEMPLATE = """<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FastLED Examples</title>
+    <link href="https://fonts.googleapis.com/css2?family=Roboto+Condensed:wght@300&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <link rel="stylesheet" href="index.css">
+</head>
+<body>
+    <div class="splash-screen">
+        <div class="splash-text">FastLED</div>
+    </div>
+    <div class="content-wrapper">
+        <div class="nav-trigger">Examples <i class="fas fa-chevron-down"></i></div>
+        <nav class="nav-pane">
+            {example_links}
+        </nav>
+        <main class="main-content">
+            <iframe id="example-frame" title="Example Content"></iframe>
+        </main>
+    </div>
+    <script>
+        document.addEventListener('DOMContentLoaded', function() {{
+            const splashScreen = document.querySelector('.splash-screen');
+            const splashText = document.querySelector('.splash-text');
+            
+            // Ensure splash screen always gets removed
+            const removeSplashScreen = () => {{
+                splashScreen.style.opacity = '0';
+                setTimeout(() => {{
+                    splashScreen.style.display = 'none';
+                }}, 500);
+            }};
+
+            // Set a maximum time the splash screen can stay
+            const maxSplashTime = setTimeout(removeSplashScreen, 2000); // Reduced from 5000ms to 2000ms
+
+            // Try to do nice fade-in/fade-out when possible
+            try {{
+                // Add a fallback timer in case font loading fails silently
+                const fontTimeout = setTimeout(() => {{
+                    splashText.style.opacity = '1';
+                    setTimeout(removeSplashScreen, 1000);
+                }}, 1000);
+
+                Promise.all([
+                    // Wrap font loading in a timeout promise
+                    Promise.race([
+                        document.fonts.ready,
+                        new Promise((_, reject) => setTimeout(reject, 1500))
+                    ]),
+                    new Promise(resolve => {{
+                        if (document.readyState === 'complete') {{
+                            resolve();
+                        }} else {{
+                            window.addEventListener('load', resolve);
+                        }}
+                    }})
+                ]).then(() => {{
+                    clearTimeout(maxSplashTime);
+                    clearTimeout(fontTimeout);
+                    splashText.style.opacity = '1';
+                    setTimeout(removeSplashScreen, 1500);
+                }}).catch(() => {{
+                    // If either promise fails, ensure splash screen is removed
+                    clearTimeout(maxSplashTime);
+                    removeSplashScreen();
+                }});
+            }} catch (e) {{
+                // Final fallback if anything goes wrong
+                console.warn('Splash screen error:', e);
+                removeSplashScreen();
+            }}
+            const links = document.querySelectorAll('.example-link');
+            const iframe = document.getElementById('example-frame');
+            const navPane = document.querySelector('.nav-pane');
+            const navTrigger = document.querySelector('.nav-trigger');
+            
+            // First add checkmarks to all links
+            links.forEach(link => {{
+                // Add the checkmark span to each link
+                const checkmark = document.createElement('i');
+                checkmark.className = 'fas fa-check';
+                checkmark.style.display = 'none';
+                checkmark.style.position = 'absolute';
+                checkmark.style.right = '10px';
+                checkmark.style.top = '50%';
+                checkmark.style.transform = 'translateY(-50%)';
+                checkmark.style.color = '#E0E0E0';
+                link.appendChild(checkmark);
+            }});
+            
+            // Now load first example and show its checkmark
+            if (links.length > 0) {{
+                // Try to find SdCard example first
+                let startLink = Array.from(links).find(link => link.textContent === 'SdCard') || links[0];
+                iframe.src = startLink.getAttribute('href');
+                startLink.classList.add('active');
+                startLink.querySelector('.fa-check').style.display = 'inline-block';
+            }}
+            
+            // Add click handlers
+            links.forEach(link => {{
+                link.addEventListener('click', function(e) {{
+                    e.preventDefault();
+                    // Hide all checkmarks
+                    links.forEach(l => {{
+                        l.querySelector('.fa-check').style.display = 'none';
+                        l.classList.remove('active');
+                    }});
+                    // Show this checkmark
+                    this.querySelector('.fa-check').style.display = 'inline-block';
+                    this.classList.add('active');
+                    iframe.src = this.getAttribute('href');
+                    hideNav();  // Hide nav after selection
+                }});
+            }});
+
+            function showNav() {{
+                navPane.classList.add('visible');
+                navPane.style.opacity = '1';
+            }}
+
+            function hideNav() {{
+                navPane.style.opacity = '0';  // Start fade out
+                setTimeout(() => {{
+                    navPane.classList.remove('visible');
+                }}, 300);
+            }}
+
+            // Click handlers for nav
+            navTrigger.addEventListener('click', (e) => {{
+                e.stopPropagation();
+                if (navPane.classList.contains('visible')) {{
+                    hideNav();
+                }} else {{
+                    showNav();
+                }}
+            }});
+            
+            // Close menu when clicking anywhere in the document
+            document.addEventListener('click', (e) => {{
+                if (navPane.classList.contains('visible') && 
+                    !navPane.contains(e.target) && 
+                    !navTrigger.contains(e.target)) {{
+                    hideNav();
+                }}
+            }});
+
+            // Close when clicking iframe
+            iframe.addEventListener('load', () => {{
+                iframe.contentDocument?.addEventListener('click', () => {{
+                    if (navPane.classList.contains('visible')) {{
+                        hideNav();
+                    }}
+                }});
+            }});
+
+            // Initial state
+            hideNav();
+        }});
+    </script>
+</body>
+</html>
+"""
+
+
+EXAMPLES = [
+    "wasm",
+    "Chromancer",
+    "LuminescentGrand",
+    "FxSdCard",
+    "FxNoiseRing",
+    "FxWater",
+]
+
+
+def _exec(cmd: str) -> None:
+    subprocess.run(cmd, shell=True, check=True)
+
+
+def build_example(example: str, outputdir: Path) -> None:
+    if not which("fastled"):
+        raise FileNotFoundError("fastled executable not found")
+    src_dir = outputdir / example / "src"
+    _exec(f"fastled --init={example} {src_dir}")
+    assert src_dir.exists()
+    _exec(f"fastled {src_dir / example} --just-compile")
+    fastled_dir = src_dir / example / "fastled_js"
+    assert fastled_dir.exists(), f"fastled dir {fastled_dir} not found"
+    # now copy it to the example dir
+    example_dir = outputdir / example
+    copytree(fastled_dir, example_dir, dirs_exist_ok=True)
+    # now remove the src dir
+    rmtree(src_dir, ignore_errors=True)
+    print(f"Built {example} example in {example_dir}")
+    assert (example_dir / "fastled.wasm").exists()
+
+
+def generate_css(outputdir: Path) -> None:
+    css_file = outputdir / "index.css"
+    # with open(css_file, "w") as f:
+    #    f.write(CSS_CONTENT, encoding="utf-8")
+    css_file.write_text(CSS_CONTENT, encoding="utf-8")
+
+
+def build_index_html(outputdir: Path) -> None:
+    outputdir = outputdir
+    assert (
+        outputdir.exists()
+    ), f"Output directory {outputdir} not found, you should run build_example first"
+    index_html = outputdir / "index.html"
+
+    examples = [f for f in outputdir.iterdir() if f.is_dir()]
+    examples = sorted(examples)
+
+    example_links = "\n".join(
+        f'    <a class="example-link" href="{example.name}/index.html">{example.name}</a>'
+        for example in examples
+    )
+
+    with open(index_html, "w") as f:
+        f.write(INDEX_TEMPLATE.format(example_links=example_links))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Build FastLED example site")
+    parser.add_argument(
+        "--outputdir", type=Path, help="Output directory", required=True
+    )
+    parser.add_argument(
+        "--fast",
+        action="store_true",
+        help="Skip regenerating existing examples, only rebuild index.html and CSS",
+    )
+    return parser.parse_args()
+
+
+def build(outputdir: Path, fast: bool | None = None, check=False) -> list[Exception]:
+    outputdir = outputdir
+    fast = fast or False
+    errors: list[Exception] = []
+
+    for example in EXAMPLES:
+        example_dir = outputdir / example
+        if not fast or not example_dir.exists():
+            try:
+                build_example(example=example, outputdir=outputdir)
+            except Exception as e:
+                if check:
+                    raise
+                errors.append(e)
+
+    try:
+        generate_css(outputdir=outputdir)
+    except Exception as e:
+        if check:
+            raise
+        errors.append(e)
+
+    try:
+        build_index_html(outputdir=outputdir)
+    except Exception as e:
+        if check:
+            raise
+        errors.append(e)
+
+    return errors
+
+
+def main() -> int:
+    args = parse_args()
+    outputdir = args.outputdir
+    fast = args.fast
+    build(outputdir=outputdir, fast=fast)
+    return 0
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.argv.append("--fast")
+    main()

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/can_run_local_docker_tests.py

@@ -0,0 +1,13 @@
+import os
+import platform
+
+
+def can_run_local_docker_tests() -> bool:
+    """Check if this system can run Docker Tests"""
+    is_github_runner = "GITHUB_ACTIONS" in os.environ
+    if not is_github_runner:
+        from fastled.docker_manager import DockerManager
+
+        return DockerManager.is_docker_installed()
+    # this only works in ubuntu at the moment
+    return platform.system() == "Linux"

fastled/test/examples.py

@@ -0,0 +1,49 @@
+from tempfile import TemporaryDirectory
+from time import time
+from warnings import warn
+
+_FILTER = True
+
+
+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(host=host) if examples is None else examples
+    if host is None and _FILTER:
+        examples.remove("Chromancer")  # Brutal
+        examples.remove("LuminescentGrand")
+    with TemporaryDirectory() as tmpdir:
+        for example in examples:
+            print(f"Initializing example: {example}")
+            try:
+                sketch_dir = Api.project_init(example, outputdir=tmpdir, host=host)
+            except Exception as e:
+                warn(f"Failed to initialize example: {example}, error: {e}")
+                out[example] = e
+                continue
+            print(f"Project initialized at: {sketch_dir}")
+            start = time()
+            print(f"Compiling example: {example}")
+            diff = time() - start
+            print(f"Compilation took: {diff:.2f} seconds")
+            result = Api.web_compile(sketch_dir, host=host)
+            if not result.success:
+                out[example] = Exception(result.stdout)
+    return out
+
+
+def unit_test() -> None:
+    from fastled import Api
+
+    with Api.server(auto_updates=True) as server:
+        out = test_examples(host=server.url())
+        if out:
+            raise RuntimeError(f"Failed tests: {out}")
+
+
+if __name__ == "__main__":
+    unit_test()