fastled 1.2.33__py3-none-any.whl → 1.4.50__py3-none-any.whl

fastled/playwright/resize_tracking.py

@@ -0,0 +1,127 @@
+"""
+Resize tracking for Playwright browser integration.
+
+This module provides a class to track browser window resize events and adjust
+the viewport accordingly without using internal polling loops.
+"""
+
+from typing import Any
+
+
+class ResizeTracker:
+    """Tracks browser window resize events and adjusts viewport accordingly."""
+
+    def __init__(self, page: Any):
+        """Initialize the resize tracker.
+
+        Args:
+            page: The Playwright page object to track
+        """
+        self.page = page
+        self.last_outer_size: tuple[int, int] | None = None
+
+    async def _get_window_info(self) -> dict[str, int] | None:
+        """Get browser window dimensions information.
+
+        Returns:
+            Dictionary containing window dimensions or None if unable to retrieve
+        """
+        if self.page is None:
+            return None
+
+        try:
+            return await self.page.evaluate(
+                """
+                () => {
+                    return {
+                        outerWidth: window.outerWidth,
+                        outerHeight: window.outerHeight,
+                        innerWidth: window.innerWidth,
+                        innerHeight: window.innerHeight,
+                        contentWidth: document.documentElement.clientWidth,
+                        contentHeight: document.documentElement.clientHeight
+                    };
+                }
+                """
+            )
+        except Exception:
+            return None
+
+    async def set_viewport_size(self, width: int, height: int) -> None:
+        """Set the viewport size.
+
+        Args:
+            width: The viewport width
+            height: The viewport height
+        """
+        if self.page is None:
+            raise Exception("Page is None")
+
+        await self.page.set_viewport_size({"width": width, "height": height})
+
+    async def update(self) -> Exception | None:
+        """Update the resize tracking and adjust viewport if needed.
+
+        Returns:
+            None if successful, Exception if an error occurred
+        """
+        try:
+            # Check if page is still alive
+            if self.page is None or self.page.is_closed():
+                return Exception("Page closed")
+
+            window_info = await self._get_window_info()
+
+            if window_info:
+                current_outer = (
+                    window_info["outerWidth"],
+                    window_info["outerHeight"],
+                )
+
+                # Check if window size changed
+                if (
+                    self.last_outer_size is None
+                    or current_outer != self.last_outer_size
+                ):
+
+                    if self.last_outer_size is not None:
+                        print("[PYTHON] *** BROWSER WINDOW RESIZED ***")
+                        print(
+                            f"[PYTHON] Outer window changed from {self.last_outer_size[0]}x{self.last_outer_size[1]} to {current_outer[0]}x{current_outer[1]}"
+                        )
+
+                    self.last_outer_size = current_outer
+
+                    # Set viewport to match the outer window size
+                    outer_width = int(window_info["outerWidth"])
+                    outer_height = int(window_info["outerHeight"])
+
+                    print(
+                        f"[PYTHON] Setting viewport to match outer window size: {outer_width}x{outer_height}"
+                    )
+
+                    await self.set_viewport_size(outer_width, outer_height)
+                    print("[PYTHON] Viewport set successfully")
+
+                    # Query the actual window dimensions after the viewport change
+                    updated_window_info = await self._get_window_info()
+
+                    if updated_window_info:
+                        print(f"[PYTHON] Updated window info: {updated_window_info}")
+
+                        # Update our tracking with the actual final outer size
+                        self.last_outer_size = (
+                            updated_window_info["outerWidth"],
+                            updated_window_info["outerHeight"],
+                        )
+                        print(
+                            f"[PYTHON] Updated last_outer_size to actual final size: {self.last_outer_size}"
+                        )
+                    else:
+                        print("[PYTHON] Could not get updated window info")
+
+        except Exception as e:
+            return e
+
+        # Success case
+        return None

fastled/print_filter.py

@@ -0,0 +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"

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,10 +1,134 @@
 from pathlib import Path
+from typing import Callable, TypeVar, Union
 
-from fastled.string_diff import string_diff_paths
+from fastled.string_diff import string_diff
+
+T = TypeVar("T")
+
+
+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
+        )
+
+    # Try fuzzy matching as fallback
+    # For better fuzzy matching on paths, extract just the last component (basename)
+    # to avoid the "examples/" prefix interfering with matching
+    from pathlib import Path as PathLib
+
+    option_basenames = []
+    for option in options:
+        option_str = option_to_str(option)
+        # Extract basename for fuzzy matching
+        basename = (
+            PathLib(option_str).name
+            if "/" in option_str or "\\" in option_str
+            else option_str
+        )
+        option_basenames.append(basename)
+
+    fuzzy_results = string_diff(user_input, option_basenames)
+
+    if fuzzy_results:
+        # Map fuzzy results back to original options
+        fuzzy_matches = []
+        for _, matched_basename in fuzzy_results:
+            for i, basename in enumerate(option_basenames):
+                if basename == matched_basename:
+                    fuzzy_matches.append(options[i])
+                    break
+
+        if len(fuzzy_matches) == 1:
+            return fuzzy_matches[0]
+        elif len(fuzzy_matches) > 1:
+            # Recursive disambiguation with fuzzy matches
+            return _disambiguate_user_choice(
+                fuzzy_matches,
+                option_to_str,
+                f"Multiple fuzzy matches for '{user_input}':",
+                0,
+            )
+
+    # 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(
-    sketch_directories: list[Path], cwd_is_fastled: bool
+    sketch_directories: list[Path], cwd_is_fastled: bool, is_followup: bool = False
 ) -> str | None:
     if cwd_is_fastled:
         exclude = ["src", "dev", "tests"]
@@ -17,19 +141,20 @@ 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: ").strip()
-        try:
-            index = int(which) - 1
-            return str(sketch_directories[index])
-        except (ValueError, IndexError):
-            inputs = [p for p in sketch_directories]
-            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:
-                return select_sketch_directory([p for _, p in top_hits], cwd_is_fastled)
+        # First scan with >4 directories: return None (too many to auto-select)
+        if not is_followup and len(sketch_directories) > 4:
+            return None
+
+        # Prompt user to disambiguate
+        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)
     return None