fastled 1.2.46__tar.gz → 1.2.49__tar.gz

{fastled-1.2.46 → fastled-1.2.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fastled
-Version: 1.2.46
+Version: 1.2.49
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -294,7 +294,6 @@ A: `delay()` will block `loop()` which blocks the main thread of the browser. Th
 Q: How can I get the compiled size of my FastLED sketch smaller?
 A: A big chunk of space is being used by unnecessary javascript `emscripten` bundling. The wasm_compiler_settings.py file in the FastLED repo can tweak this.
 
-
 # Revisions
 
   * 1.2.31 - Bunch of fixes and ease of use while compiling code in the repo.

{fastled-1.2.46 → fastled-1.2.49}/README.md

@@ -268,7 +268,6 @@ A: `delay()` will block `loop()` which blocks the main thread of the browser. Th
 Q: How can I get the compiled size of my FastLED sketch smaller?
 A: A big chunk of space is being used by unnecessary javascript `emscripten` bundling. The wasm_compiler_settings.py file in the FastLED repo can tweak this.
 
-
 # Revisions
 
   * 1.2.31 - Bunch of fixes and ease of use while compiling code in the repo.

{fastled-1.2.46 → fastled-1.2.49}/compiler/code_sync.py

@@ -5,12 +5,10 @@ from typing import Callable
 
 from compile_lock import COMPILE_LOCK
 
-VOLUME_MAPPED_SRC = Path("/host/fastled/src")
-RSYNC_DEST = Path("/js/fastled/src")
 TIME_START = time.time()
 
 
-def sync_src_to_target(
+def _sync_src_to_target(
     src: Path, dst: Path, callback: Callable[[], None] | None = None
 ) -> bool:
     """Sync the volume mapped source directory to the FastLED source directory."""
@@ -70,13 +68,39 @@ def sync_src_to_target(
     return False
 
 
-def sync_source_directory_if_volume_is_mapped(
-    callback: Callable[[], None] | None = None,
-) -> bool:
-    """Sync the volume mapped source directory to the FastLED source directory."""
-    if not VOLUME_MAPPED_SRC.exists():
-        # Volume is not mapped in so we don't rsync it.
-        print("Skipping rsync, as fastled src volume not mapped")
-        return False
-    print("Syncing source directories because host is mapped in")
-    return sync_src_to_target(VOLUME_MAPPED_SRC, RSYNC_DEST, callback=callback)
+class CodeSync:
+
+    def __init__(self, volume_mapped_src: Path, rsync_dest: Path):
+        self.volume_mapped_src = volume_mapped_src
+        self.rsync_dest = rsync_dest
+
+    def sync_src_to_target(
+        self,
+        volume_mapped_src: Path | None = None,
+        rsync_dest: Path | None = None,
+        callback: Callable[[], None] | None = None,
+    ) -> bool:
+        """Sync the volume mapped source directory to the FastLED source directory."""
+
+        if volume_mapped_src is None or rsync_dest is None:
+            assert (
+                volume_mapped_src is None and rsync_dest is None
+            ), f"Both must be None: {volume_mapped_src} {rsync_dest}"
+        volume_mapped_src = volume_mapped_src or self.volume_mapped_src
+        rsync_dest = rsync_dest or self.rsync_dest
+        return _sync_src_to_target(
+            self.volume_mapped_src, self.rsync_dest, callback=callback
+        )
+
+    def sync_source_directory_if_volume_is_mapped(
+        self,
+        callback: Callable[[], None] | None = None,
+    ) -> bool:
+        """Sync the volume mapped source directory to the FastLED source directory."""
+        if not self.volume_mapped_src.exists():
+            # Volume is not mapped in so we don't rsync it.
+            print("Skipping rsync, as fastled src volume not mapped")
+            return False
+        print("Syncing source directories because host is mapped in")
+        out: bool = self.sync_src_to_target(callback=callback)
+        return out

{fastled-1.2.46 → fastled-1.2.49}/compiler/compile.py

@@ -17,12 +17,28 @@ import re
 import shutil
 import subprocess
 import sys
+import traceback
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
 from typing import List
 
+from paths import COMPILER_ROOT, FASTLED_COMPILER_DIR, PIO_BUILD_DIR, SKETCH_SRC
+
+_FASTLED_MODULES_DIR = FASTLED_COMPILER_DIR / "modules"
+_INDEX_HTML_SRC = FASTLED_COMPILER_DIR / "index.html"
+_INDEX_CSS_SRC = FASTLED_COMPILER_DIR / "index.css"
+_INDEX_JS_SRC = FASTLED_COMPILER_DIR / "index.js"
+
+
+_WASM_COMPILER_SETTTINGS = FASTLED_COMPILER_DIR / "wasm_compiler_flags.py"
+# _OUTPUT_FILES = ["fastled.js", "fastled.wasm"]
+_HEADERS_TO_INSERT = ["#include <Arduino.h>", '#include "platforms/wasm/js.h"']
+_FILE_EXTENSIONS = [".ino", ".h", ".hpp", ".cpp"]
+# _MAX_COMPILE_ATTEMPTS = 1  # Occasionally the compiler fails for unknown reasons, but disabled because it increases the build time on failure.
+_FASTLED_OUTPUT_DIR_NAME = "fastled_js"
+
 
 @dataclass
 class DateLine:
@@ -51,41 +67,6 @@ class SyntaxCheckResult:
     message: str
 
 
-_CHECK_SYNTAX = False
-_COMPILER_PATH = "em++"
-
-_JS_DIR = Path("/js")
-_FASTLED_DIR = _JS_DIR / "fastled"
-_FASTLED_SRC = _FASTLED_DIR / "src"
-# FASTLED_SRC_PLATFORMS = _FASTLED_SRC / "platforms"
-# FASTLED_SRC_PLATFORMS_WASM = FASTLED_SRC_PLATFORMS / "wasm"
-# _FASTLED_SRC_PLATFORMS_WASM_COMPILER = FASTLED_SRC_PLATFORMS_WASM / "compiler"
-_FASTLED_SRC_PLATFORMS_WASM_COMPILER = _JS_DIR / "compiler"
-
-
-_JS_SRC = _JS_DIR / "src"
-
-_FASTLED_DIR = _JS_DIR / "fastled"
-# FASTLED_SRC_DIR = _FASTLED_DIR / "src"
-# FASTLED_PLATFORMS_DIR = FASTLED_SRC_DIR / "platforms"
-# FASTLED_WASM_DIR = FASTLED_PLATFORMS_DIR / "wasm"
-_FASTLED_COMPILER_DIR = _JS_DIR / "compiler"
-_FASTLED_MODULES_DIR = _FASTLED_COMPILER_DIR / "modules"
-
-_PIO_BUILD_DIR = _JS_DIR / ".pio/build"
-_INDEX_HTML_SRC = _FASTLED_COMPILER_DIR / "index.html"
-_INDEX_CSS_SRC = _FASTLED_COMPILER_DIR / "index.css"
-_INDEX_JS_SRC = _FASTLED_COMPILER_DIR / "index.js"
-
-
-_WASM_COMPILER_SETTTINGS = _JS_DIR / "wasm_compiler_flags.py"
-_OUTPUT_FILES = ["fastled.js", "fastled.wasm"]
-_HEADERS_TO_INSERT = ["#include <Arduino.h>", '#include "platforms/wasm/js.h"']
-_FILE_EXTENSIONS = [".ino", ".h", ".hpp", ".cpp"]
-_MAX_COMPILE_ATTEMPTS = 1  # Occasionally the compiler fails for unknown reasons, but disabled because it increases the build time on failure.
-_FASTLED_OUTPUT_DIR_NAME = "fastled_js"
-
-
 def copy_files(src_dir: Path, js_src: Path) -> None:
     print("Copying files from mapped directory to container...")
     for item in src_dir.iterdir():
@@ -98,7 +79,7 @@ def copy_files(src_dir: Path, js_src: Path) -> None:
 
 
 def compile(
-    _JS_DIR: Path, build_mode: BuildMode, auto_clean: bool, no_platformio: bool
+    compiler_root: Path, build_mode: BuildMode, auto_clean: bool, no_platformio: bool
 ) -> int:
     print("Starting compilation process...")
     max_attempts = 1
@@ -111,7 +92,7 @@ def compile(
         cmd_list = [
             "/bin/bash",
             "-c",
-            "/js/build_fast.sh",
+            (compiler_root / "build_fast.sh").as_posix(),
         ]
     else:
         cmd_list.extend(["pio", "run"])
@@ -121,7 +102,7 @@ def compile(
     def _open_process(cmd_list: list[str] = cmd_list) -> subprocess.Popen:
         out = subprocess.Popen(
             cmd_list,
-            cwd=_JS_DIR,
+            cwd=compiler_root,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             universal_newlines=True,
@@ -135,6 +116,7 @@ def compile(
             print(f"Attempting compilation (attempt {attempt}/{max_attempts})...")
             process = _open_process()
             assert process.stdout is not None
+            line: str
             for line in process.stdout:
                 processed_line = line.replace("fastled/src", "src")
                 timestamped_line = _timestamp_output(processed_line)
@@ -221,89 +203,6 @@ def process_ino_files(src_dir: Path) -> None:
     print("Transform to cpp and insert header operations completed.")
 
 
-def check_syntax_with_gcc(file_path, gcc_path="gcc"):
-    """
-    Perform syntax checking on a C or C++ source file using GCC.
-
-    Parameters:
-        file_path (str): Path to the source file to check.
-        gcc_path (str): Path to the GCC executable (default is 'gcc').
-
-    Returns:
-        bool: True if syntax is correct, False otherwise.
-        str: Output or error message from GCC.
-    """
-    try:
-        # Run GCC with -fsyntax-only flag for syntax checking
-        cmd_list = [
-            gcc_path,
-            "-fsyntax-only",
-            "-std=gnu++20",
-            "-fpermissive",
-            "-Wno-everything",  # Suppress all warnings
-            "-I",
-            "/js/src/",  # Add /js/src/ to the include path
-            "-I",
-            "/js/fastled/src/",  # Add /js/fastled/src/ to the include path
-            "-I",
-            "/emsdk/upstream/emscripten/system/include",
-            "-I",
-            "/js/fastled/src/platforms/wasm/compiler",  # Arduino.h and Arduino.cpp
-            file_path,
-        ]
-        cmd_str = subprocess.list2cmdline(cmd_list)
-        print(f"Running command: {cmd_str}")
-        result = subprocess.run(
-            cmd_list,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-
-        # Check the return code to determine if syntax is valid
-        if result.returncode == 0:
-            return True, "Syntax check passed successfully."
-        else:
-            return False, result.stderr
-    except FileNotFoundError:
-        return False, f"GCC not found at {gcc_path}."
-    except Exception as e:
-        return False, str(e)
-
-
-def check_syntax(
-    directory_path: Path, gcc_path: str = "gcc"
-) -> list[SyntaxCheckResult]:
-    # os walk
-    out: list[SyntaxCheckResult] = []
-    exclusion_list = set("fastled_js")
-    for root, dirs, files in os.walk(directory_path):
-        # if sub directory is in exclusion list, skip
-        dirs[:] = [d for d in dirs if d not in exclusion_list]
-        for file in files:
-            if file.endswith(".cpp") or file.endswith(".ino"):
-                file_path = os.path.join(root, file)
-                is_valid, message = check_syntax_with_gcc(file_path, gcc_path)
-                if not is_valid:
-                    print(f"Syntax check failed for file: {file_path}")
-                    print(f"Error message: {message}")
-                    out.append(
-                        SyntaxCheckResult(
-                            file_path=Path(file_path), is_valid=False, message=message
-                        )
-                    )
-                else:
-                    print(f"Syntax check passed for file: {file_path}")
-                    out.append(
-                        SyntaxCheckResult(
-                            file_path=Path(file_path),
-                            is_valid=True,
-                            message="Syntax check passed successfully.",
-                        )
-                    )
-    return out
-
-
 def _make_timestamps_relative(stdout: str) -> str:
     def parse(line: str) -> DateLine:
         parts = line.split(" ")
@@ -351,7 +250,35 @@ def _timestamp_output(line: str) -> str:
     return f"{timestamp} {line.rstrip()}"
 
 
-def parse_args() -> argparse.Namespace:
+@dataclass
+class Args:
+    mapped_dir: Path
+    keep_files: bool
+    only_copy: bool
+    only_insert_header: bool
+    only_compile: bool
+    profile: bool
+    disable_auto_clean: bool
+    no_platformio: bool
+    debug: bool
+    quick: bool
+    release: bool
+
+    def __post_init__(self):
+        assert isinstance(self.mapped_dir, Path)
+        assert isinstance(self.keep_files, bool)
+        assert isinstance(self.only_copy, bool)
+        assert isinstance(self.only_insert_header, bool)
+        assert isinstance(self.only_compile, bool)
+        assert isinstance(self.profile, bool)
+        assert isinstance(self.disable_auto_clean, bool)
+        assert isinstance(self.no_platformio, bool)
+        assert isinstance(self.debug, bool)
+        assert isinstance(self.quick, bool)
+        assert isinstance(self.release, bool)
+
+
+def parse_args() -> Args:
     parser = argparse.ArgumentParser(description="Compile FastLED for WASM")
     parser.add_argument(
         "--mapped-dir",
@@ -405,7 +332,20 @@ def parse_args() -> argparse.Namespace:
         "--release", action="store_true", help="Build in release mode"
     )
 
-    return parser.parse_args()
+    tmp = parser.parse_args()
+    return Args(
+        mapped_dir=tmp.mapped_dir,
+        keep_files=tmp.keep_files,
+        only_copy=tmp.only_copy,
+        only_insert_header=tmp.only_insert_header,
+        only_compile=tmp.only_compile,
+        profile=tmp.profile,
+        disable_auto_clean=tmp.disable_auto_clean,
+        no_platformio=tmp.no_platformio,
+        debug=tmp.debug,
+        quick=tmp.quick,
+        release=tmp.release,
+    )
 
 
 def find_project_dir(mapped_dir: Path) -> Path:
@@ -420,10 +360,10 @@ def find_project_dir(mapped_dir: Path) -> Path:
 
 
 def process_compile(
-    _JS_DIR: Path, build_mode: BuildMode, auto_clean: bool, no_platformio: bool
+    js_dir: Path, build_mode: BuildMode, auto_clean: bool, no_platformio: bool
 ) -> None:
     print("Starting compilation...")
-    rtn = compile(_JS_DIR, build_mode, auto_clean, no_platformio=no_platformio)
+    rtn = compile(js_dir, build_mode, auto_clean, no_platformio=no_platformio)
     print(f"Compilation return code: {rtn}")
     if rtn != 0:
         print("Compilation failed.")
@@ -431,7 +371,7 @@ def process_compile(
     print("Compilation successful.")
 
 
-def cleanup(args: argparse.Namespace, js_src: Path) -> None:
+def cleanup(args: Args, js_src: Path) -> None:
     if not args.keep_files and not (args.only_copy or args.only_insert_header):
         print("Removing temporary source files")
         shutil.rmtree(js_src)
@@ -447,33 +387,15 @@ def hash_file(file_path: Path) -> str:
     return hasher.hexdigest()
 
 
-def main() -> int:
-
-    # assert _JS_DIR.exists()
-    # assert ARDUINO_H_SRC.exists()
-    # assert _INDEX_HTML_SRC.exists()
-    # assert _INDEX_CSS_SRC.exists(), f"Index CSS not found at {_INDEX_CSS_SRC}"
-    # assert _INDEX_JS_SRC.exists()
-    # assert _WASM_COMPILER_SETTTINGS.exists()
-    # assert _FASTLED_SRC_PLATFORMS_WASM_COMPILER.exists()
-    # assert _JS_DIR.exists(), f"_JS_DIR does not exist: {_JS_DIR}"
-    # assert ARDUINO_H_SRC.exists(), f"ARDUINO_H_SRC does not exist: {ARDUINO_H_SRC}"
-    # assert _INDEX_HTML_SRC.exists(), f"_INDEX_HTML_SRC does not exist: {_INDEX_HTML_SRC}"
-    # assert _INDEX_CSS_SRC.exists(), f"_INDEX_CSS_SRC does not exist: {_INDEX_CSS_SRC}"
-    # assert _INDEX_JS_SRC.exists(), f"_INDEX_JS_SRC does not exist: {_INDEX_JS_SRC}"
-    # assert (
-    #     _WASM_COMPILER_SETTTINGS.exists()
-    # ), f"_WASM_COMPILER_SETTTINGS does not exist: {_WASM_COMPILER_SETTTINGS}"
-
+def run(args: Args) -> int:
     check_paths: list[Path] = [
-        _JS_DIR,
+        COMPILER_ROOT,
         _INDEX_HTML_SRC,
         _INDEX_CSS_SRC,
         _INDEX_JS_SRC,
         _WASM_COMPILER_SETTTINGS,
-        _FASTLED_SRC_PLATFORMS_WASM_COMPILER,
+        FASTLED_COMPILER_DIR,
     ]
-
     missing_paths = [p for p in check_paths if not p.exists()]
     if missing_paths:
         print("The following paths are missing:")
@@ -483,7 +405,6 @@ def main() -> int:
         raise FileNotFoundError(f"Missing required paths: {missing_paths_str}")
 
     print("Starting FastLED WASM compilation script...")
-    args = parse_args()
     print(f"Keep files flag: {args.keep_files}")
     print(f"Using mapped directory: {args.mapped_dir}")
 
@@ -493,9 +414,7 @@ def main() -> int:
         os.environ["EMPROFILE"] = "2"
 
     try:
-        if _JS_SRC.exists():
-            shutil.rmtree(_JS_SRC)
-        _JS_SRC.mkdir(parents=True, exist_ok=True)
+
         src_dir = find_project_dir(args.mapped_dir)
 
         any_only_flags = args.only_copy or args.only_insert_header or args.only_compile
@@ -504,31 +423,23 @@ def main() -> int:
         do_insert_header = not any_only_flags or args.only_insert_header
         do_compile = not any_only_flags or args.only_compile
 
+        if not any_only_flags:
+            if SKETCH_SRC.exists():
+                shutil.rmtree(SKETCH_SRC)
+
+        SKETCH_SRC.mkdir(parents=True, exist_ok=True)
+
         if do_copy:
-            copy_files(src_dir, _JS_SRC)
+            copy_files(src_dir, SKETCH_SRC)
             if args.only_copy:
                 return 0
 
         if do_insert_header:
-            process_ino_files(_JS_SRC)
+            process_ino_files(SKETCH_SRC)
             if args.only_insert_header:
                 print("Transform to cpp and insert header operations completed.")
                 return 0
 
-        if _CHECK_SYNTAX:
-            print("Performing syntax check...")
-            syntax_results = check_syntax(
-                directory_path=_JS_SRC, gcc_path=_COMPILER_PATH
-            )
-            failed_checks = [r for r in syntax_results if not r.is_valid]
-            if failed_checks:
-                print("\nSyntax check failed!")
-                for result in failed_checks:
-                    print(f"\nFile: {result.file_path}")
-                    print(f"Error: {result.message}")
-                return 1
-            print("Syntax check passed for all files.")
-
         no_platformio: bool = args.no_platformio
 
         if do_compile:
@@ -543,7 +454,7 @@ def main() -> int:
                     build_mode = BuildMode.QUICK
 
                 process_compile(
-                    _JS_DIR=_JS_DIR,
+                    js_dir=COMPILER_ROOT,
                     build_mode=build_mode,
                     auto_clean=not args.disable_auto_clean,
                     no_platformio=no_platformio,
@@ -553,16 +464,16 @@ def main() -> int:
                 return 1
 
             def _get_build_dir_platformio() -> Path:
-                build_dirs = [d for d in _PIO_BUILD_DIR.iterdir() if d.is_dir()]
+                build_dirs = [d for d in PIO_BUILD_DIR.iterdir() if d.is_dir()]
                 if len(build_dirs) != 1:
                     raise RuntimeError(
-                        f"Expected exactly one build directory in {_PIO_BUILD_DIR}, found {len(build_dirs)}: {build_dirs}"
+                        f"Expected exactly one build directory in {PIO_BUILD_DIR}, found {len(build_dirs)}: {build_dirs}"
                     )
                 build_dir: Path = build_dirs[0]
                 return build_dir
 
             def _get_build_dir_cmake() -> Path:
-                return _JS_DIR / "build"
+                return COMPILER_ROOT / "build"
 
             if no_platformio:
                 build_dir = _get_build_dir_cmake()
@@ -570,45 +481,43 @@ def main() -> int:
                 build_dir = _get_build_dir_platformio()
 
             print("Copying output files...")
-            fastled__JS_DIR: Path = src_dir / _FASTLED_OUTPUT_DIR_NAME
-            fastled__JS_DIR.mkdir(parents=True, exist_ok=True)
+            out_dir: Path = src_dir / _FASTLED_OUTPUT_DIR_NAME
+            out_dir.mkdir(parents=True, exist_ok=True)
 
             for file in ["fastled.js", "fastled.wasm"]:
                 _src = build_dir / file
-                _dst = fastled__JS_DIR / file
+                _dst = out_dir / file
                 print(f"Copying {_src} to {_dst}")
                 shutil.copy2(_src, _dst)
 
             print(f"Copying {_INDEX_HTML_SRC} to output directory")
-            shutil.copy2(_INDEX_HTML_SRC, fastled__JS_DIR / "index.html")
+            shutil.copy2(_INDEX_HTML_SRC, out_dir / "index.html")
             print(f"Copying {_INDEX_CSS_SRC} to output directory")
-            shutil.copy2(_INDEX_CSS_SRC, fastled__JS_DIR / "index.css")
+            shutil.copy2(_INDEX_CSS_SRC, out_dir / "index.css")
 
             # copy all js files in _FASTLED_COMPILER_DIR to output directory
-            Path(fastled__JS_DIR / "modules").mkdir(parents=True, exist_ok=True)
+            Path(out_dir / "modules").mkdir(parents=True, exist_ok=True)
             for _file in _FASTLED_MODULES_DIR.iterdir():
                 if _file.suffix == ".js":
                     print(f"Copying {_file} to output directory")
-                    shutil.copy2(_file, fastled__JS_DIR / "modules" / _file.name)
+                    shutil.copy2(_file, out_dir / "modules" / _file.name)
 
             fastled_js_mem = build_dir / "fastled.js.mem"
             fastled_wasm_map = build_dir / "fastled.wasm.map"
             fastled_js_symbols = build_dir / "fastled.js.symbols"
             if fastled_js_mem.exists():
                 print(f"Copying {fastled_js_mem} to output directory")
-                shutil.copy2(fastled_js_mem, fastled__JS_DIR / fastled_js_mem.name)
+                shutil.copy2(fastled_js_mem, out_dir / fastled_js_mem.name)
             if fastled_wasm_map.exists():
                 print(f"Copying {fastled_wasm_map} to output directory")
-                shutil.copy2(fastled_wasm_map, fastled__JS_DIR / fastled_wasm_map.name)
+                shutil.copy2(fastled_wasm_map, out_dir / fastled_wasm_map.name)
             if fastled_js_symbols.exists():
                 print(f"Copying {fastled_js_symbols} to output directory")
-                shutil.copy2(
-                    fastled_js_symbols, fastled__JS_DIR / fastled_js_symbols.name
-                )
+                shutil.copy2(fastled_js_symbols, out_dir / fastled_js_symbols.name)
             print("Copying index.js to output directory")
-            shutil.copy2(_INDEX_JS_SRC, fastled__JS_DIR / "index.js")
+            shutil.copy2(_INDEX_JS_SRC, out_dir / "index.js")
             optional_input_data_dir = src_dir / "data"
-            output_data_dir = fastled__JS_DIR / optional_input_data_dir.name
+            output_data_dir = out_dir / optional_input_data_dir.name
 
             # Handle data directory if it exists
             manifest: list[dict] = []
@@ -657,15 +566,14 @@ def main() -> int:
             # Write manifest file even if empty
             print("Writing manifest files.json")
             manifest_json_str = json.dumps(manifest, indent=2, sort_keys=True)
-            with open(fastled__JS_DIR / "files.json", "w") as f:
+            with open(out_dir / "files.json", "w") as f:
                 f.write(manifest_json_str)
-        cleanup(args, _JS_SRC)
+        cleanup(args, SKETCH_SRC)
 
         print("Compilation process completed successfully")
         return 0
 
     except Exception as e:
-        import traceback
 
         stacktrace = traceback.format_exc()
         print(stacktrace)
@@ -673,5 +581,10 @@ def main() -> int:
         return 1
 
 
+def main() -> int:
+    args = parse_args()
+    return run(args)
+
+
 if __name__ == "__main__":
     sys.exit(main())

{fastled-1.2.46 → fastled-1.2.49}/compiler/init_runtime.py

@@ -4,18 +4,18 @@ import warnings
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 
-HERE = Path(__file__).parent
-
+COMPILER_ROOT = Path("/js")
+COMPILER_DIR = COMPILER_ROOT / "compiler"
+FASTLED_COMPILER_DIR = COMPILER_ROOT / "fastled/src/platforms/wasm/compiler"
 
-_COMPILER_DIR = Path("/js/compiler")
-_FASTLED_COMPILER_DIR = Path("/js/fastled/src/platforms/wasm/compiler")
+HERE = Path(__file__).parent
 
 
 def copy_task(src: str | Path) -> None:
     src = Path(src)
     if "entrypoint.sh" in str(src):
         return
-    link_dst = Path("/js") / src.name
+    link_dst = COMPILER_ROOT / src.name
 
     # Handle shell scripts
     if src.suffix == ".sh":
@@ -46,7 +46,6 @@ def make_links() -> None:
         "*.hpp",
         "*.cpp",
         "*.py",
-        "*.css",
         "*.sh",
         "*.ino",
         "*.ini",
@@ -56,10 +55,10 @@ def make_links() -> None:
     # Get all matching files in compiler directory
     files = []
     for pattern in patterns:
-        files.extend(glob.glob(str(_COMPILER_DIR / pattern)))
+        files.extend(glob.glob(str(COMPILER_DIR / pattern)))
 
     for pattern in patterns:
-        files.extend(glob.glob(str(_FASTLED_COMPILER_DIR / pattern)))
+        files.extend(glob.glob(str(FASTLED_COMPILER_DIR / pattern)))
 
     # Process files in parallel using ThreadPoolExecutor
     with ThreadPoolExecutor(max_workers=16) as executor: