fastled 1.4.18__py3-none-any.whl → 1.4.20__py3-none-any.whl

fastled/__version__.py

@@ -1,6 +1,6 @@
 # IMPORTANT! There's a bug in github which will REJECT any version update
 # that has any other change in the repo. Please bump the version as the
 # ONLY change in a commit, or else the pypi update and the release will fail.
-__version__ = "1.4.18"
+__version__ = "1.4.20"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

fastled/args.py

@@ -16,6 +16,7 @@ class Args:
     app: bool  # New flag to trigger Playwright browser with browser download if needed
     auto_update: bool | None
     update: bool
+    background_update: bool
     localhost: bool
     build: bool
     server: bool
@@ -57,6 +58,9 @@ class Args:
             args.no_auto_updates, bool | None
         ), f"expected bool | None, got {type(args.no_auto_updates)}"
         assert isinstance(args.update, bool), f"expected bool, got {type(args.update)}"
+        assert isinstance(
+            args.background_update, bool
+        ), f"expected bool, got {type(args.background_update)}"
         assert isinstance(
             args.localhost, bool
         ), f"expected bool, got {type(args.localhost)}"
@@ -88,6 +92,7 @@ class Args:
             app=args.app,
             auto_update=not args.no_auto_updates,
             update=args.update,
+            background_update=args.background_update,
             localhost=args.localhost,
             build=args.build,
             server=args.server,

fastled/client_server.py

@@ -243,14 +243,35 @@ def _try_make_compile_server(
         return None
 
 
-def _is_local_host(host: str) -> bool:
+def _background_update_docker_image() -> None:
+    """Perform docker image update in the background."""
+    try:
+        print("\n🔄 Starting background update of docker image...")
+        docker_manager = DockerManager()
+        updated = docker_manager.validate_or_download_image(
+            image_name=IMAGE_NAME, tag="latest", upgrade=True
+        )
+        if updated:
+            print("✅ Background docker image update completed successfully.")
+        else:
+            print("ℹ️  Docker image was already up to date.")
+    except KeyboardInterrupt:
+        print("⚠️  Background docker image update interrupted by user.")
+        import _thread
+
+        _thread.interrupt_main()
+    except Exception as e:
+        print(f"⚠️  Background docker image update failed: {e}")
+
+
+def _is_local_host(url: str) -> bool:
     return (
-        host.startswith("http://localhost")
-        or host.startswith("http://127.0.0.1")
-        or host.startswith("http://0.0.0.0")
-        or host.startswith("http://[::]")
-        or host.startswith("http://[::1]")
-        or host.startswith("http://[::ffff:127.0.0.1]")
+        url.startswith("http://localhost")
+        or url.startswith("http://127.0.0.1")
+        or url.startswith("http://0.0.0.0")
+        or url.startswith("http://[::]")
+        or url.startswith("http://[::1]")
+        or url.startswith("http://[::ffff:127.0.0.1]")
     )
 
 
@@ -268,6 +289,7 @@ def run_client(
     clear: bool = False,
     no_platformio: bool = False,
     app: bool = False,  # Use app-like browser experience
+    background_update: bool = False,
 ) -> int:
     has_checked_newer_version_yet = False
     compile_server: CompileServer | None = None
@@ -426,9 +448,20 @@ def run_client(
                     )
                     if has_update:
                         print(f"\n🔄 {message}")
-                        print(
-                            "Run with `fastled -u` to update the docker image to the latest version."
-                        )
+                        if background_update:
+                            # Start background update in a separate thread
+                            update_thread = threading.Thread(
+                                target=_background_update_docker_image, daemon=True
+                            )
+                            update_thread.start()
+                            background_update = False
+                        else:
+                            print(
+                                "Run with `fastled -u` to update the docker image to the latest version."
+                            )
+                            print(
+                                "Or use `--background-update` to update automatically in the background after compilation."
+                            )
                 except Exception as e:
                     # Don't let Docker check failures interrupt the main flow
                     warnings.warn(f"Failed to check for Docker image updates: {e}")
@@ -513,6 +546,7 @@ def run_client_server(args: Args) -> int:
     profile = bool(args.profile)
     web: str | bool = args.web if isinstance(args.web, str) else bool(args.web)
     auto_update = bool(args.auto_update)
+    background_update = bool(args.background_update)
     localhost = bool(args.localhost)
     directory = args.directory if args.directory else Path(".")
     just_compile = bool(args.just_compile)
@@ -585,6 +619,7 @@ def run_client_server(args: Args) -> int:
             clear=args.clear,
             no_platformio=no_platformio,
             app=app,
+            background_update=background_update,
         )
     except KeyboardInterrupt:
         return 1

fastled/filewatcher.py

@@ -122,6 +122,9 @@ class FileChangedNotifier(threading.Thread):
                 time.sleep(0.1)
         except KeyboardInterrupt:
             print("File watcher stopped by user.")
+            import _thread
+
+            _thread.interrupt_main()
         finally:
             self.stop()
 

fastled/parse_args.py

@@ -34,6 +34,7 @@ FastLED WASM Compiler - Useful options:
   --quick               Build in quick mode (default)
   --profile             Enable profiling the C++ build system
   --update              Update the docker image for the wasm compiler
+  --background-update   Update the docker image in the background after compilation
   --purge               Remove all FastLED containers and images
   --version             Show version information
   --help                Show detailed help
@@ -41,6 +42,7 @@ Examples:
   fastled (will auto detect the sketch directory and prompt you)
   fastled my_sketch
   fastled my_sketch --web (compiles using the web compiler only)
+  fastled my_sketch --background-update (compiles and updates docker image in background)
   fastled --init Blink (initializes a new sketch directory with the Blink example)
   fastled --server (runs the compiler server in the current directory)
 
@@ -132,6 +134,11 @@ def parse_args() -> Args:
         action="store_true",
         help="Update the wasm compiler (if necessary) before running",
     )
+    parser.add_argument(
+        "--background-update",
+        action="store_true",
+        help="Update the docker image in the background after compilation (user doesn't have to wait)",
+    )
     parser.add_argument(
         "--localhost",
         "--local",

fastled/playwright/playwright_browser.py

@@ -562,6 +562,11 @@ class PlaywrightBrowserProxy:
                     # Force exit the entire program
                     os._exit(0)
 
+            except KeyboardInterrupt:
+                print("[MAIN] Browser monitor interrupted by user")
+                import _thread
+
+                _thread.interrupt_main()
             except Exception as e:
                 print(f"[MAIN] Error monitoring browser process: {e}")
 

fastled/print_filter.py

@@ -1,52 +1,52 @@
-import re
-from abc import ABC, abstractmethod
-from enum import Enum
-
-
-class PrintFilter(ABC):
-    """Abstract base class for filtering text output."""
-
-    def __init__(self, echo: bool = True) -> None:
-        self.echo = echo
-
-    @abstractmethod
-    def filter(self, text: str) -> str:
-        """Filter the text according to implementation-specific rules."""
-        pass
-
-    def print(self, text: str | bytes) -> str:
-        """Prints the text to the console after filtering."""
-        if isinstance(text, bytes):
-            text = text.decode("utf-8")
-        text = self.filter(text)
-        if self.echo:
-            print(text, end="")
-        return text
-
-
-def _handle_ino_cpp(line: str) -> str:
-    if ".ino.cpp" in line[0:30]:
-        # Extract the filename without path and extension
-        match = re.search(r"src/([^/]+)\.ino\.cpp", line)
-        if match:
-            filename = match.group(1)
-            # Replace with examples/Filename/Filename.ino format
-            line = line.replace(
-                f"src/{filename}.ino.cpp", f"examples/{filename}/{filename}.ino"
-            )
-        else:
-            # Fall back to simple extension replacement if regex doesn't match
-            line = line.replace(".ino.cpp", ".ino")
-    return line
-
-
-class PrintFilterDefault(PrintFilter):
-    """Provides default filtering for FastLED output."""
-
-    def filter(self, text: str) -> str:
-        return text
-
-
-class CompileOrLink(Enum):
-    COMPILE = "compile"
-    LINK = "link"
+import re
+from abc import ABC, abstractmethod
+from enum import Enum
+
+
+class PrintFilter(ABC):
+    """Abstract base class for filtering text output."""
+
+    def __init__(self, echo: bool = True) -> None:
+        self.echo = echo
+
+    @abstractmethod
+    def filter(self, text: str) -> str:
+        """Filter the text according to implementation-specific rules."""
+        pass
+
+    def print(self, text: str | bytes) -> str:
+        """Prints the text to the console after filtering."""
+        if isinstance(text, bytes):
+            text = text.decode("utf-8")
+        text = self.filter(text)
+        if self.echo:
+            print(text, end="")
+        return text
+
+
+def _handle_ino_cpp(line: str) -> str:
+    if ".ino.cpp" in line[0:30]:
+        # Extract the filename without path and extension
+        match = re.search(r"src/([^/]+)\.ino\.cpp", line)
+        if match:
+            filename = match.group(1)
+            # Replace with examples/Filename/Filename.ino format
+            line = line.replace(
+                f"src/{filename}.ino.cpp", f"examples/{filename}/{filename}.ino"
+            )
+        else:
+            # Fall back to simple extension replacement if regex doesn't match
+            line = line.replace(".ino.cpp", ".ino")
+    return line
+
+
+class PrintFilterDefault(PrintFilter):
+    """Provides default filtering for FastLED output."""
+
+    def filter(self, text: str) -> str:
+        return text
+
+
+class CompileOrLink(Enum):
+    COMPILE = "compile"
+    LINK = "link"

fastled/string_diff.py

@@ -1,165 +1,165 @@
-from pathlib import Path
-
-from rapidfuzz import fuzz
-
-
-def _filter_out_obvious_bad_choices(
-    input_str: str, string_list: list[str]
-) -> list[str]:
-    """
-    Filter out strings that are too different from the input string.
-    This is a heuristic and may not be perfect.
-    """
-    if not input_str.strip():  # Handle empty input
-        return string_list
-
-    input_chars = set(input_str.lower())
-    filtered_list = []
-    for s in string_list:
-        # Check if at least half of the input characters are in the string
-        s_chars = set(s.lower())
-        common_chars = input_chars.intersection(s_chars)
-        if len(common_chars) >= len(input_chars) / 2:
-            filtered_list.append(s)
-    return filtered_list
-
-
-def is_in_order_match(input_str: str, other: str) -> bool:
-    """
-    Check if the input string is an in-order match for any string in the list.
-    An in-order match means that the characters of the input string appear
-    in the same order in the string from the list, ignoring spaces in the input.
-    """
-
-    # Remove spaces from input string for matching
-    input_chars = [c.lower() for c in input_str if c != " "]
-    other_chars = [c.lower() for c in other]
-    input_index = 0
-    other_index = 0
-    while input_index < len(input_chars) and other_index < len(other_chars):
-        if input_chars[input_index] == other_chars[other_index]:
-            input_index += 1
-        other_index += 1
-    # If we reached the end of the input string, it means all characters were found in order
-    if input_index == len(input_chars):
-        return True
-    return False
-
-
-# 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
-
-    # Handle empty input or empty list
-    if not input_string.strip():
-        # Return all strings with equal distance for empty input
-        return [(i, s) for i, s in enumerate(string_list)]
-
-    if not string_list:
-        return []
-
-    map_string: dict[str, str] = {}
-
-    if ignore_case:
-        map_string = {s.lower(): s for s in string_list}
-    else:
-        map_string = {s: s for s in string_list}
-
-    original_string_list = string_list.copy()
-    if ignore_case:
-        string_list = [s.lower() for s in string_list]
-        input_string = input_string.lower()
-
-    # Check for exact matches, but also check if there are other substring matches
-    exact_matches = [s for s in string_list if s == input_string]
-    substring_matches = [s for s in string_list if input_string in s]
-
-    # If there's an exact match AND other substring matches, return all substring matches
-    # This provides better user experience for partial matching
-    if exact_matches and len(substring_matches) > 1:
-        out: list[tuple[float, str]] = []
-        for i, s in enumerate(substring_matches):
-            s_mapped = map_string.get(s, s)
-            out.append((i, s_mapped))
-        return out
-
-    # If there's only an exact match and no other substring matches, return just the exact match
-    if exact_matches and len(substring_matches) == 1:
-        out: list[tuple[float, str]] = []
-        for i, s in enumerate(exact_matches):
-            s_mapped = map_string.get(s, s)
-            out.append((i, s_mapped))
-        return out
-
-    # Apply set membership filtering for queries with 3+ characters
-    if len(input_string.strip()) >= 3:
-        filtered = _filter_out_obvious_bad_choices(input_string, string_list)
-        if filtered:  # Only apply filter if it doesn't eliminate everything
-            string_list = filtered
-
-    # Second filter: exact substring filtering if applicable
-    if substring_matches:
-        string_list = substring_matches
-        # Return all substring matches
-        out: list[tuple[float, str]] = []
-        for i, s in enumerate(string_list):
-            s_mapped = map_string.get(s, s)
-            out.append((i, s_mapped))
-        return out
-
-    # Third filter: in order exact match filtering if applicable.
-    in_order_matches = [s for s in string_list if is_in_order_match(input_string, s)]
-    if in_order_matches:
-        string_list = in_order_matches
-
-    # Calculate distances
-    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))
-
-    # Handle case where no strings remain after filtering
-    if not distances:
-        # Fall back to original list and calculate distances
-        string_list = original_string_list.copy()
-        if ignore_case:
-            string_list = [s.lower() for s in string_list]
-
-        distances = []
-        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:
-            s = string_list[i]
-            s_mapped = map_string.get(s, s)
-            out.append((i, s_mapped))
-
-    return out
-
-
-def string_diff_paths(
-    input_string: str | Path, path_list: list[Path], ignore_case=True
-) -> list[tuple[float, Path]]:
-    # Normalize path separators to forward slashes for consistent comparison
-    string_list = [str(p).replace("\\", "/") for p in path_list]
-    input_str = str(input_string).replace("\\", "/")
-
-    tmp = string_diff(input_str, string_list, ignore_case)
-    out: list[tuple[float, Path]] = []
-    for i, j in tmp:
-        # Find the original path that matches the normalized result
-        for idx, orig_path in enumerate(path_list):
-            if str(orig_path).replace("\\", "/") == j:
-                out.append((i, orig_path))
-                break
-    return out
+from pathlib import Path
+
+from rapidfuzz import fuzz
+
+
+def _filter_out_obvious_bad_choices(
+    input_str: str, string_list: list[str]
+) -> list[str]:
+    """
+    Filter out strings that are too different from the input string.
+    This is a heuristic and may not be perfect.
+    """
+    if not input_str.strip():  # Handle empty input
+        return string_list
+
+    input_chars = set(input_str.lower())
+    filtered_list = []
+    for s in string_list:
+        # Check if at least half of the input characters are in the string
+        s_chars = set(s.lower())
+        common_chars = input_chars.intersection(s_chars)
+        if len(common_chars) >= len(input_chars) / 2:
+            filtered_list.append(s)
+    return filtered_list
+
+
+def is_in_order_match(input_str: str, other: str) -> bool:
+    """
+    Check if the input string is an in-order match for any string in the list.
+    An in-order match means that the characters of the input string appear
+    in the same order in the string from the list, ignoring spaces in the input.
+    """
+
+    # Remove spaces from input string for matching
+    input_chars = [c.lower() for c in input_str if c != " "]
+    other_chars = [c.lower() for c in other]
+    input_index = 0
+    other_index = 0
+    while input_index < len(input_chars) and other_index < len(other_chars):
+        if input_chars[input_index] == other_chars[other_index]:
+            input_index += 1
+        other_index += 1
+    # If we reached the end of the input string, it means all characters were found in order
+    if input_index == len(input_chars):
+        return True
+    return False
+
+
+# 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
+
+    # Handle empty input or empty list
+    if not input_string.strip():
+        # Return all strings with equal distance for empty input
+        return [(i, s) for i, s in enumerate(string_list)]
+
+    if not string_list:
+        return []
+
+    map_string: dict[str, str] = {}
+
+    if ignore_case:
+        map_string = {s.lower(): s for s in string_list}
+    else:
+        map_string = {s: s for s in string_list}
+
+    original_string_list = string_list.copy()
+    if ignore_case:
+        string_list = [s.lower() for s in string_list]
+        input_string = input_string.lower()
+
+    # Check for exact matches, but also check if there are other substring matches
+    exact_matches = [s for s in string_list if s == input_string]
+    substring_matches = [s for s in string_list if input_string in s]
+
+    # If there's an exact match AND other substring matches, return all substring matches
+    # This provides better user experience for partial matching
+    if exact_matches and len(substring_matches) > 1:
+        out: list[tuple[float, str]] = []
+        for i, s in enumerate(substring_matches):
+            s_mapped = map_string.get(s, s)
+            out.append((i, s_mapped))
+        return out
+
+    # If there's only an exact match and no other substring matches, return just the exact match
+    if exact_matches and len(substring_matches) == 1:
+        out: list[tuple[float, str]] = []
+        for i, s in enumerate(exact_matches):
+            s_mapped = map_string.get(s, s)
+            out.append((i, s_mapped))
+        return out
+
+    # Apply set membership filtering for queries with 3+ characters
+    if len(input_string.strip()) >= 3:
+        filtered = _filter_out_obvious_bad_choices(input_string, string_list)
+        if filtered:  # Only apply filter if it doesn't eliminate everything
+            string_list = filtered
+
+    # Second filter: exact substring filtering if applicable
+    if substring_matches:
+        string_list = substring_matches
+        # Return all substring matches
+        out: list[tuple[float, str]] = []
+        for i, s in enumerate(string_list):
+            s_mapped = map_string.get(s, s)
+            out.append((i, s_mapped))
+        return out
+
+    # Third filter: in order exact match filtering if applicable.
+    in_order_matches = [s for s in string_list if is_in_order_match(input_string, s)]
+    if in_order_matches:
+        string_list = in_order_matches
+
+    # Calculate distances
+    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))
+
+    # Handle case where no strings remain after filtering
+    if not distances:
+        # Fall back to original list and calculate distances
+        string_list = original_string_list.copy()
+        if ignore_case:
+            string_list = [s.lower() for s in string_list]
+
+        distances = []
+        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:
+            s = string_list[i]
+            s_mapped = map_string.get(s, s)
+            out.append((i, s_mapped))
+
+    return out
+
+
+def string_diff_paths(
+    input_string: str | Path, path_list: list[Path], ignore_case=True
+) -> list[tuple[float, Path]]:
+    # Normalize path separators to forward slashes for consistent comparison
+    string_list = [str(p).replace("\\", "/") for p in path_list]
+    input_str = str(input_string).replace("\\", "/")
+
+    tmp = string_diff(input_str, string_list, ignore_case)
+    out: list[tuple[float, Path]] = []
+    for i, j in tmp:
+        # Find the original path that matches the normalized result
+        for idx, orig_path in enumerate(path_list):
+            if str(orig_path).replace("\\", "/") == j:
+                out.append((i, orig_path))
+                break
+    return out