fastled 1.4.42__py3-none-any.whl → 1.4.44__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.42"
+__version__ = "1.4.44"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

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

@@ -22,20 +22,27 @@ def get_examples(host: str | None = None) -> list[str]:
 
 
 def _prompt_for_example() -> str:
+    from fastled.select_sketch_directory import _disambiguate_user_choice
+
     examples = get_examples()
-    while True:
-        print("Available examples:")
-        for i, example in enumerate(examples):
-            print(f"  [{i+1}]: {example}")
-        answer = input("Enter the example number or name: ").strip()
-        if answer.isdigit():
-            example_num = int(answer) - 1
-            if example_num < 0 or example_num >= len(examples):
-                print("Invalid example number")
-                continue
-            return examples[example_num]
-        elif answer in examples:
-            return answer
+
+    # Find default example index (prefer DEFAULT_EXAMPLE if it exists)
+    default_index = 0
+    if DEFAULT_EXAMPLE in examples:
+        default_index = examples.index(DEFAULT_EXAMPLE)
+
+    result = _disambiguate_user_choice(
+        examples,
+        option_to_str=lambda x: x,
+        prompt="Available examples:",
+        default_index=default_index,
+    )
+
+    if result is None:
+        # Fallback to DEFAULT_EXAMPLE if user cancelled
+        return DEFAULT_EXAMPLE
+
+    return result
 
 
 class DownloadThread(threading.Thread):

fastled/select_sketch_directory.py

@@ -1,8 +1,90 @@
 from pathlib import Path
+from typing import Callable, TypeVar, Union
 
-from rapidfuzz import fuzz
+T = TypeVar("T")
 
-from fastled.string_diff import string_diff_paths
+
+def _disambiguate_user_choice(
+    options: list[T],
+    option_to_str: Callable[[T], str] = str,
+    prompt: str = "Multiple matches found. Please choose:",
+    default_index: int = 0,
+) -> Union[T, None]:
+    """
+    Present multiple options to the user with a default selection.
+
+    Args:
+        options: List of options to choose from
+        option_to_str: Function to convert option to display string
+        prompt: Prompt message to show user
+        default_index: Index of the default option (0-based)
+
+    Returns:
+        Selected option or None if cancelled
+    """
+    if not options:
+        return None
+
+    if len(options) == 1:
+        return options[0]
+
+    # Ensure default_index is valid
+    if default_index < 0 or default_index >= len(options):
+        default_index = 0
+
+    print(f"\n{prompt}")
+    for i, option in enumerate(options):
+        option_str = option_to_str(option)
+        if i == default_index:
+            print(f"  [{i+1}]: [{option_str}]")  # Default option shown in brackets
+        else:
+            print(f"  [{i+1}]: {option_str}")
+
+    default_option_str = option_to_str(options[default_index])
+    user_input = input(
+        f"\nEnter number or name (default: [{default_option_str}]): "
+    ).strip()
+
+    # Handle empty input - select default
+    if not user_input:
+        return options[default_index]
+
+    # Try to parse as number
+    try:
+        index = int(user_input) - 1
+        if 0 <= index < len(options):
+            return options[index]
+    except ValueError:
+        pass
+
+    # Try to match by name (case insensitive)
+    user_input_lower = user_input.lower()
+    for option in options:
+        option_str = option_to_str(option).lower()
+        if option_str == user_input_lower:
+            return option
+
+    # Try partial match
+    matches = []
+    for option in options:
+        option_str = option_to_str(option)
+        if user_input_lower in option_str.lower():
+            matches.append(option)
+
+    if len(matches) == 1:
+        return matches[0]
+    elif len(matches) > 1:
+        # Recursive disambiguation with the filtered matches
+        return _disambiguate_user_choice(
+            matches,
+            option_to_str,
+            f"Multiple partial matches for '{user_input}':",
+            0,  # Reset default to first match
+        )
+
+    # No match found
+    print(f"No match found for '{user_input}'. Please try again.")
+    return _disambiguate_user_choice(options, option_to_str, prompt, default_index)
 
 
 def select_sketch_directory(
@@ -19,49 +101,21 @@ def select_sketch_directory(
         print(f"\nUsing sketch directory: {sketch_directories[0]}")
         return str(sketch_directories[0])
     elif len(sketch_directories) > 1:
-        print("\nMultiple Directories found, choose one:")
-        for i, sketch_dir in enumerate(sketch_directories):
-            print(f"  [{i+1}]: {sketch_dir}")
-        which = input(
-            "\nPlease specify a sketch directory\nYou can enter a number or type a fuzzy search: "
-        ).strip()
-        try:
-            index = int(which) - 1
-            return str(sketch_directories[index])
-        except (ValueError, IndexError):
-            inputs = [p for p in sketch_directories]
-
-            if is_followup:
-                # On follow-up, find the closest match by fuzzy distance
-                distances = []
-                for path in inputs:
-                    path_str = str(path).replace("\\", "/")
-                    dist = fuzz.token_sort_ratio(which.lower(), path_str.lower())
-                    distances.append((dist, path))
-
-                # Get the best distance and return the closest match(es)
-                best_distance = max(distances, key=lambda x: x[0])[0]
-                best_matches = [
-                    path for dist, path in distances if dist == best_distance
-                ]
-
-                if len(best_matches) == 1:
-                    example = best_matches[0]
-                    return str(example)
-                else:
-                    # If still multiple matches with same distance, recurse again
-                    return select_sketch_directory(
-                        best_matches, cwd_is_fastled, is_followup=True
-                    )
-            else:
-                # First call - use original fuzzy matching (allows ambiguity)
-                top_hits: list[tuple[float, Path]] = string_diff_paths(which, inputs)
-                if len(top_hits) == 1:
-                    example = top_hits[0][1]
-                    return str(example)
-                else:
-                    # Recursive call with is_followup=True for more precise matching
-                    return select_sketch_directory(
-                        [p for _, p in top_hits], cwd_is_fastled, is_followup=True
-                    )
+        if is_followup:
+            # Only disambiguate on follow-up calls
+            result = _disambiguate_user_choice(
+                sketch_directories,
+                option_to_str=lambda x: str(x),
+                prompt="Multiple Directories found, choose one:",
+                default_index=0,
+            )
+
+            if result is None:
+                return None
+
+            return str(result)
+        else:
+            # On first call, use the first directory automatically
+            print(f"\nUsing sketch directory: {sketch_directories[0]}")
+            return str(sketch_directories[0])
     return None

fastled/version.py

@@ -1,41 +1,41 @@
-from concurrent.futures import Future, ThreadPoolExecutor
-
-import httpx
-
-from fastled.__version__ import __version_url_latest__
-
-
-def _fetch_version() -> str | Exception:
-    """
-    Helper function to fetch the latest version from the GitHub repository.
-    """
-    try:
-        response = httpx.get(__version_url_latest__)
-        response.raise_for_status()
-        # Extract the version string from the response text
-        version_line = response.text.split("__version__ = ")[1].split('"')[1]
-        return version_line
-    except Exception as e:
-        return e
-
-
-def get_latest_version() -> Future[str | Exception]:
-    """
-    Fetch the latest version from the GitHub repository.
-    Returns a future that will resolve with the version string or an exception.
-    """
-    executor = ThreadPoolExecutor()
-    return executor.submit(_fetch_version)
-
-
-def unit_test() -> None:
-    future = get_latest_version()
-    latest_version = future.result()  # Wait for the future to complete
-    if isinstance(latest_version, Exception):
-        print(f"Error fetching latest version: {latest_version}")
-    else:
-        print(f"Latest version: {latest_version}")
-
-
-if __name__ == "__main__":
-    unit_test()
+from concurrent.futures import Future, ThreadPoolExecutor
+
+import httpx
+
+from fastled.__version__ import __version_url_latest__
+
+
+def _fetch_version() -> str | Exception:
+    """
+    Helper function to fetch the latest version from the GitHub repository.
+    """
+    try:
+        response = httpx.get(__version_url_latest__)
+        response.raise_for_status()
+        # Extract the version string from the response text
+        version_line = response.text.split("__version__ = ")[1].split('"')[1]
+        return version_line
+    except Exception as e:
+        return e
+
+
+def get_latest_version() -> Future[str | Exception]:
+    """
+    Fetch the latest version from the GitHub repository.
+    Returns a future that will resolve with the version string or an exception.
+    """
+    executor = ThreadPoolExecutor()
+    return executor.submit(_fetch_version)
+
+
+def unit_test() -> None:
+    future = get_latest_version()
+    latest_version = future.result()  # Wait for the future to complete
+    if isinstance(latest_version, Exception):
+        print(f"Error fetching latest version: {latest_version}")
+    else:
+        print(f"Latest version: {latest_version}")
+
+
+if __name__ == "__main__":
+    unit_test()