fastled 1.3.30__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

@@ -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,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,21 +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\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]
-            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

fastled/server_flask.py

@@ -85,6 +85,14 @@ def _run_flask_server(
 
         # logger.error(f"Server error: {e}")
 
+        @app.after_request
+        def add_security_headers(response):
+            """Add security headers required for cross-origin isolation and audio worklets"""
+            # Required for SharedArrayBuffer and audio worklets
+            response.headers["Cross-Origin-Embedder-Policy"] = "credentialless"
+            response.headers["Cross-Origin-Opener-Policy"] = "same-origin"
+            return response
+
         @app.before_request
         def log_request_info():
             """Log details of each request before processing"""
@@ -333,7 +341,35 @@ def _run_flask_server(
         # server.watch(str(fastled_js / "index.css"))
         # Start the server
         logger.info(f"Starting server on port {port}")
-        server.serve(port=port, debug=True)
+
+        # Configure SSL if certificates are provided
+        if certfile and keyfile:
+            logger.info(
+                f"Configuring SSL with certfile: {certfile}, keyfile: {keyfile}"
+            )
+            # Monkey-patch the server to use SSL
+            # The livereload Server doesn't expose ssl_context directly,
+            # so we need to use the underlying tornado server
+            import ssl
+
+            from tornado import httpserver
+            from tornado.ioloop import IOLoop
+            from tornado.wsgi import WSGIContainer
+
+            # Create SSL context
+            ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+            ssl_ctx.load_cert_chain(str(certfile), str(keyfile))
+
+            # Wrap the WSGI app in Tornado's WSGIContainer
+            wsgi_container = WSGIContainer(server.app)  # type: ignore[arg-type]
+
+            # Create HTTP server with SSL
+            http_server = httpserver.HTTPServer(wsgi_container, ssl_options=ssl_ctx)
+            http_server.listen(port)
+            logger.info(f"HTTPS server started on port {port}")
+            IOLoop.current().start()
+        else:
+            server.serve(port=port, debug=True)
     except KeyboardInterrupt:
         logger.info("Server stopped by keyboard interrupt")
         import _thread

fastled/settings.py

@@ -1,16 +1,60 @@
 import os
 import platform
+import sys
 
 FILE_CHANGED_DEBOUNCE_SECONDS = 2.0
 MACHINE = platform.machine().lower()
 IS_ARM: bool = "arm" in MACHINE or "aarch64" in MACHINE
 PLATFORM_TAG: str = "-arm64" if IS_ARM else ""
-CONTAINER_NAME = f"fastled-wasm-container{PLATFORM_TAG}"
+
+
+def _is_running_under_github_actions() -> bool:
+    """Detect if we're running under github actions."""
+    return "GITHUB_ACTIONS" in os.environ
+
+
+def _is_running_under_pytest() -> bool:
+    """Detect if we're running under pytest."""
+    # Check if pytest is in the loaded modules
+    if "pytest" in sys.modules:
+        return True
+
+    # Check for pytest environment variables
+    if "PYTEST_CURRENT_TEST" in os.environ:
+        return True
+
+    return False
+
+
+def _get_container_name() -> str:
+    """Get the appropriate container name based on runtime context."""
+    base_name = "fastled-wasm-container"
+
+    if not _is_running_under_github_actions() and _is_running_under_pytest():
+        # Use test container name when running under pytest
+        return f"{base_name}-test{PLATFORM_TAG}"
+    else:
+        # Use regular container name
+        return f"{base_name}{PLATFORM_TAG}"
+
+
+def _get_server_port() -> int:
+    """Get the appropriate server port based on runtime context."""
+    if not _is_running_under_github_actions() and _is_running_under_pytest():
+        # Use test port when running under pytest to avoid conflicts
+        return 9022
+    else:
+        # Use regular port
+        return 9021
+
+
+CONTAINER_NAME = _get_container_name()
 DEFAULT_URL = str(os.environ.get("FASTLED_URL", "https://fastled.onrender.com"))
-SERVER_PORT = 9021
+SERVER_PORT = _get_server_port()
+AUTH_TOKEN = "oBOT5jbsO4ztgrpNsQwlmFLIKB"
 
 IMAGE_NAME = "niteris/fastled-wasm"
-DEFAULT_CONTAINER_NAME = "fastled-wasm-container"
+DEFAULT_CONTAINER_NAME = _get_container_name()
 # IMAGE_TAG = "latest"
 
 DOCKER_FILE = (