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

fastled-1.0.17.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.1
+Name: fastled
+Version: 1.0.17
+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.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.17.dist-info/RECORD

@@ -0,0 +1,18 @@
+fled/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fled/app.py,sha256=EwP7CrMT7cEmc4A-rIEN7uEC77k6NFPATT2zkyMSKcY,11362
+fled/build_mode.py,sha256=joMwsV4K1y_LijT4gEAcjx69RZBoe_KmFmHZdPYbL_4,631
+fled/check_cpp_syntax.py,sha256=YxRJm7cFPv4bdhL1v_KOkBz8RL86ihayoJYvclr69ms,1024
+fled/cli.py,sha256=g2oXoJAmpUYEgXCLVzu0fekJjgWhuLCpXmCkl8kvCQI,234
+fled/compile_server.py,sha256=Hj2Hem4M4cD2NkdRwZj5q4Y6vdonnpaRk2pAWSwnsC8,7991
+fled/docker_manager.py,sha256=eEc12bmQEER7xf-7ehfYJgQua9cDB1IlLVuuw_9eflI,8934
+fled/filewatcher.py,sha256=SHKx9Dnt4EJiT-iPYakdPZBRIL1gsJGN9tY8FJW2myU,5079
+fled/open_browser.py,sha256=-VhpGmydwLCcXmrDD2esMEdJPZYcoX2Mt73eb88Nna0,1392
+fled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
+fled/web_compile.py,sha256=9_TJ_R8Iv6WTbLvZ_nVNrpfWPWBanhXbi8l_O-ADyCM,6369
+fled/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
+fastled-1.0.17.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.0.17.dist-info/METADATA,sha256=-J_L3EyUBKaEezj59c8kN7XdfGbTiApo0WA1urjHnSE,5230
+fastled-1.0.17.dist-info/WHEEL,sha256=0VNUDWQJzfRahYI3neAhz2UVbRCtztpN5dPHAGvmGXc,109
+fastled-1.0.17.dist-info/entry_points.txt,sha256=aw_M3Wl5jLJEJm0wlVD3Hr0cDqILc9frPbKeJfdNqyM,68
+fastled-1.0.17.dist-info/top_level.txt,sha256=QuCwo_EQ7IOcAlszLUCg8n-oQZey7zyCyH3yShSLwcQ,11
+fastled-1.0.17.dist-info/RECORD,,

fastled-1.0.17.dist-info/entry_points.txt

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

fastled-1.0.17.dist-info/top_level.txt

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

{fastled → fled}/app.py

@@ -1,5 +1,7 @@
 """
 Uses the latest wasm compiler image to compile the FastLED sketch.
+
+
 """
 
 import argparse
@@ -13,15 +15,12 @@ import time
 from dataclasses import dataclass
 from pathlib import Path
 
-from fastled import __version__
-from fastled.build_mode import BuildMode, get_build_mode
-from fastled.compile_server import CompileServer
-from fastled.docker_manager import DockerManager
-from fastled.filewatcher import FileWatcherProcess
-from fastled.keyboard import SpaceBarWatcher
-from fastled.open_browser import open_browser_thread
-from fastled.sketch import looks_like_fastled_repo, looks_like_sketch_directory
-from fastled.web_compile import ConnectionResult, find_good_connection, web_compile
+from fled.build_mode import BuildMode, get_build_mode
+from fled.compile_server import CompileServer
+from fled.docker_manager import DockerManager
+from fled.filewatcher import FileChangedNotifier
+from fled.open_browser import open_browser_thread
+from fled.web_compile import web_compile
 
 machine = platform.machine().lower()
 IS_ARM: bool = "arm" in machine or "aarch64" in machine
@@ -44,15 +43,12 @@ DOCKER = DockerManager(container_name=CONTAINER_NAME)
 
 def parse_args() -> argparse.Namespace:
     """Parse command-line arguments."""
-    parser = argparse.ArgumentParser(description=f"FastLED WASM Compiler {__version__}")
-    parser.add_argument(
-        "--version", action="version", version=f"%(prog)s {__version__}"
-    )
+    parser = argparse.ArgumentParser(description="FastLED WASM Compiler")
     parser.add_argument(
         "directory",
         type=str,
         nargs="?",
-        default=None,
+        default=os.getcwd(),
         help="Directory containing the FastLED sketch to compile",
     )
     parser.add_argument(
@@ -60,6 +56,11 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Just compile, skip opening the browser and watching for changes.",
     )
+    parser.add_argument(
+        "--no-auto-clean",
+        action="store_true",
+        help="Big performance gains for compilation, but it's flaky at this time",
+    )
     parser.add_argument(
         "--web",
         "-w",
@@ -70,10 +71,15 @@ def parse_args() -> argparse.Namespace:
         help="Use web compiler. Optional URL can be provided (default: https://fastled.onrender.com)",
     )
     parser.add_argument(
-        "-i",
-        "--interactive",
+        "--reuse",
         action="store_true",
-        help="Run in interactive mode (Not available with --web)",
+        help="Reuse the existing container if it exists. (Not available with --web)",
+    )
+    parser.add_argument(
+        "--exclude",
+        type=str,
+        nargs="+",
+        help="Additional patterns to exclude from file watching (Not available with --web)",
     )
     parser.add_argument(
         "--profile",
@@ -91,17 +97,6 @@ def parse_args() -> argparse.Namespace:
     build_mode.add_argument(
         "--release", action="store_true", help="Build in release mode"
     )
-    build_mode.add_argument(
-        "--localhost",
-        "--local",
-        action="store_true",
-        help="Use localhost for web compilation from an instance of fastled --server, creating it if necessary",
-    )
-    build_mode.add_argument(
-        "--server",
-        action="store_true",
-        help="Run the server in the current directory, volume mapping fastled if we are in the repo",
-    )
 
     build_mode.add_argument(
         "--force-compile",
@@ -109,30 +104,14 @@ def parse_args() -> argparse.Namespace:
         help="Skips the test to see if the current directory is a valid FastLED sketch directory",
     )
 
-    cwd_is_fastled = looks_like_fastled_repo(Path(os.getcwd()))
-
     args = parser.parse_args()
-    if not cwd_is_fastled and not args.localhost and not args.web and not args.server:
-        print(f"Using web compiler at {DEFAULT_URL}")
-        args.web = DEFAULT_URL
-    if cwd_is_fastled and not args.web:
-        print("Forcing --local mode because we are in the FastLED repo")
-        args.localhost = True
-    if args.localhost:
-        args.web = "localhost"
-    if args.interactive and not args.server:
-        print("--interactive forces --server mode")
-        args.server = True
-    if args.directory is None and not args.server:
-        # does current directory look like a sketch?
-        maybe_sketch_dir = Path(os.getcwd())
-        if looks_like_sketch_directory(maybe_sketch_dir):
-            args.directory = str(maybe_sketch_dir)
-        else:
-            print(
-                "\nYou either need to specify a sketch directory or run in --server mode."
-            )
-            sys.exit(1)
+
+    # Handle --web implications
+    if args.web:
+        if args.reuse:
+            parser.error("--reuse cannot be used with --web")
+        if args.exclude:
+            parser.error("--exclude cannot be used with --web")
 
     return args
 
@@ -169,7 +148,9 @@ def run_web_compiler(
 
     # now check to see if the hash value is the same as the last hash value
     if last_hash_value is not None and last_hash_value == web_result.hash_value:
-        print("\nSkipping redeploy: No significant changes found.")
+        print(
+            "\nNo significant source code changes detected and data was the same, skipping recompilation."
+        )
         print_results()
         return CompiledResult(
             success=True, fastled_js=str(output_dir), hash_value=web_result.hash_value
@@ -197,29 +178,16 @@ def run_web_compiler(
 
 
 def _try_start_server_or_get_url(args: argparse.Namespace) -> str | CompileServer:
-    is_local_host = "localhost" in args.web or "127.0.0.1" in args.web or args.localhost
-
-    # test to see if there is already a local host server
-    local_host_needs_server = False
-    if is_local_host:
-        addr = "localhost" if args.localhost else args.web
-        result: ConnectionResult | None = find_good_connection([addr])
-        if result is not None:
-            print(f"Found local server at {result.host}")
-            return result.host
-        else:
-            local_host_needs_server = True
-
-    if not local_host_needs_server and args.web:
+    if args.web:
         if isinstance(args.web, str):
             return args.web
         if isinstance(args.web, bool):
             return DEFAULT_URL
         return args.web
     else:
+        disable_auto_clean = args.no_auto_clean
         try:
-            print("No local server found, starting one...")
-            compile_server = CompileServer()
+            compile_server = CompileServer(disable_auto_clean=disable_auto_clean)
             print("Waiting for the local compiler to start...")
             if not compile_server.wait_for_startup():
                 print("Failed to start local compiler.")
@@ -232,11 +200,31 @@ def _try_start_server_or_get_url(args: argparse.Namespace) -> str | CompileServe
             return DEFAULT_URL
 
 
-def run_client(args: argparse.Namespace) -> int:
-    compile_server: CompileServer | None = None
-    open_web_browser = not args.just_compile and not args.interactive
+def _looks_like_sketch_directory(directory: Path) -> bool:
+    # 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
+
+
+def main() -> int:
+    args = parse_args()
+    open_web_browser = not args.just_compile
     profile = args.profile
-    if not args.force_compile and not looks_like_sketch_directory(Path(args.directory)):
+
+    if not args.force_compile and not _looks_like_sketch_directory(
+        Path(args.directory)
+    ):
         print(
             "Error: Not a valid FastLED sketch directory, if you are sure it is, use --force-compile"
         )
@@ -249,16 +237,16 @@ def run_client(args: argparse.Namespace) -> int:
         )
         args.web = True
 
+    compile_server: CompileServer | None = None
     url: str
+
     try:
         try:
             url_or_server: str | CompileServer = _try_start_server_or_get_url(args)
             if isinstance(url_or_server, str):
-                print(f"Found URL: {url_or_server}")
                 url = url_or_server
             else:
                 compile_server = url_or_server
-                print(f"Server started at {compile_server.url()}")
                 url = compile_server.url()
         except KeyboardInterrupt:
             print("\nExiting from first try...")
@@ -315,115 +303,49 @@ def run_client(args: argparse.Namespace) -> int:
             compile_server.stop()
         return 1
 
+    # Watch mode
     print("\nWatching for changes. Press Ctrl+C to stop...")
-    sketch_filewatcher = FileWatcherProcess(
-        args.directory, excluded_patterns=["fastled_js"]
-    )
-
-    source_code_watcher: FileWatcherProcess | None = None
-    if compile_server and compile_server.using_fastled_src_dir_volume():
-        assert compile_server.fastled_src_dir is not None
-        source_code_watcher = FileWatcherProcess(
-            compile_server.fastled_src_dir, excluded_patterns=[]
-        )
-
-    def trigger_rebuild_if_sketch_changed(
-        last_compiled_result: CompiledResult,
-    ) -> CompiledResult:
-        changed_files = sketch_filewatcher.get_all_changes()
-        if changed_files:
-            print(f"\nChanges detected in {changed_files}")
-            last_hash_value = last_compiled_result.hash_value
-            out = compile_function(last_hash_value=last_hash_value)
-            if not out.success:
-                print("\nRecompilation failed.")
-            else:
-                print("\nRecompilation successful.")
-            return out
-        return last_compiled_result
+    watcher = FileChangedNotifier(args.directory, excluded_patterns=["fastled_js"])
+    watcher.start()
 
     try:
         while True:
-            last_compiled_result = trigger_rebuild_if_sketch_changed(
-                last_compiled_result
-            )
-            if compile_server and not compile_server.proceess_running():
-                print("Server process is not running. Exiting...")
-                return 1
-            if source_code_watcher is not None:
-                changed_files = source_code_watcher.get_all_changes()
-                if changed_files:
-                    print(f"\nChanges detected in FastLED source code: {changed_files}")
-                    print("Press space bar to trigger compile.")
-
-                    space_key_watcher = SpaceBarWatcher()
-                    try:
-                        while True:
-                            if space_key_watcher.space_bar_pressed():
-                                print("Space bar pressed, triggering recompile...")
-                                last_compiled_result = compile_function(
-                                    last_hash_value=None
-                                )
-                                print("Finished recompile.")
-                                break
-                            elif len(sketch_filewatcher.get_all_changes()) > 0:
-                                last_compiled_result = compile_function(
-                                    last_hash_value=None
-                                )
-                                break
-                            time.sleep(0.1)
-                    finally:
-                        space_key_watcher.stop()
-
+            try:
+                changed_files = watcher.get_all_changes()
+            except KeyboardInterrupt:
+                print("\nExiting from watcher...")
+                raise
+            except Exception as e:
+                print(f"Error getting changes: {e}")
+                changed_files = []
+            if changed_files:
+                print(f"\nChanges detected in {changed_files}")
+                last_hash_value = last_compiled_result.hash_value
+                result = compile_function(last_hash_value=last_hash_value)
+                if not result.success:
+                    print("\nRecompilation failed.")
+                else:
+                    print("\nRecompilation successful.")
+            time.sleep(0.3)
     except KeyboardInterrupt:
+        watcher.stop()
         print("\nStopping watch mode...")
         return 0
     except Exception as e:
+        watcher.stop()
         print(f"Error: {e}")
         return 1
     finally:
-        sketch_filewatcher.stop()
+        watcher.stop()
         if compile_server:
             compile_server.stop()
         if browser_proc:
             browser_proc.kill()
 
 
-def run_server(args: argparse.Namespace) -> int:
-    interactive = args.interactive
-    compile_server = CompileServer(interactive=interactive)
-    if not interactive:
-        print(f"Server started at {compile_server.url()}")
-    compile_server.wait_for_startup()
-    try:
-        while True:
-            if not compile_server.proceess_running():
-                print("Server process is not running. Exiting...")
-                return 1
-            time.sleep(1)
-    except KeyboardInterrupt:
-        print("\nExiting from server...")
-        return 1
-    finally:
-        compile_server.stop()
-    return 0
-
-
-def main() -> int:
-    args = parse_args()
-    if args.server:
-        print("Running in server only mode.")
-        return run_server(args)
-    else:
-        print("Running in client/server mode.")
-        return run_client(args)
-
-
 if __name__ == "__main__":
     try:
-        # os.chdir("../fastled")
-        sys.argv.append("examples/SdCard")
-        sys.argv.append("--localhost")
+        sys.argv.append("examples/wasm")
         sys.exit(main())
     except KeyboardInterrupt:
         print("\nExiting from main...")

fled/check_cpp_syntax.py

@@ -0,0 +1,34 @@
+from pygments import lex
+from pygments.lexers import CppLexer
+from pygments.token import Token
+
+
+def check_cpp_syntax(code):
+    try:
+        # Tokenize the code to check for basic syntax issues
+        for token_type, token_value in lex(code, CppLexer()):
+            if token_type == Token.Error:
+                print(f"Syntax error detected: {token_value}")
+                return False
+        print("No syntax errors detected.")
+        return True
+    except Exception as e:
+        print(f"Error during syntax check: {e}")
+        return False
+
+
+def main():
+    file_path = input("Enter the path to your C++ file: ")
+    try:
+        with open(file_path, "r") as file:
+            code = file.read()
+        if check_cpp_syntax(code):
+            print("The file can now be sent to the server.")
+        else:
+            print("Please fix the syntax errors before sending.")
+    except FileNotFoundError:
+        print("File not found. Please check the path and try again.")
+
+
+if __name__ == "__main__":
+    main()

{fastled → fled}/cli.py

@@ -4,7 +4,7 @@ Main entry point.
 
 import sys
 
-from fastled.app import main as app_main
+from fled.app import main as app_main
 
 
 def main() -> int: