fastled 1.4.30__py3-none-any.whl → 1.4.32__py3-none-any.whl

fastled/playwright/playwright_browser.py

@@ -14,6 +14,8 @@ import warnings
 from pathlib import Path
 from typing import Any
 
+from fastled.playwright.resize_tracking import ResizeTracker
+
 # Set custom Playwright browser installation path
 PLAYWRIGHT_DIR = Path.home() / ".fastled" / "playwright"
 PLAYWRIGHT_DIR.mkdir(parents=True, exist_ok=True)
@@ -69,6 +71,7 @@ class PlaywrightBrowser:
         self.playwright: Any = None
         self._should_exit = asyncio.Event()
         self._extensions_dir: Path | None = None
+        self.resize_tracker: ResizeTracker | None = None
 
         # Initialize extensions if enabled
         if self.enable_extensions:
@@ -278,148 +281,97 @@ class PlaywrightBrowser:
             "[PYTHON] Setting up browser window tracking with viewport-only adjustment"
         )
 
+        # Create resize tracker instance
+        self.resize_tracker = ResizeTracker(self.page)
+
         # Start polling loop that tracks browser window changes and adjusts viewport only
         asyncio.create_task(self._track_browser_adjust_viewport())
 
     async def _track_browser_adjust_viewport(self) -> None:
         """Track browser window changes and adjust viewport accordingly.
 
-        This method polls for changes in the browser window size and adjusts
-        the viewport size to match, maintaining the browser window dimensions
-        while ensuring the content area matches the sketch requirements.
+        This method polls for changes in the browser window size using the
+        ResizeTracker and handles any errors that occur.
         """
-        last_viewport = None
-        consecutive_same_count = 0
-        max_consecutive_same = 5
+        if self.resize_tracker is None:
+            print("[PYTHON] Cannot start tracking: resize_tracker is None")
+            return
 
         while not self._should_exit.is_set():
             try:
-                await asyncio.sleep(0.5)  # Poll every 500ms
+                # Wait between polls
+                await asyncio.sleep(0.25)  # Poll every 250ms
 
-                if self.page is None:
-                    continue
-
-                # Get current viewport size
-                current_viewport = await self.page.evaluate(
-                    """
-                    () => ({
-                        width: window.innerWidth,
-                        height: window.innerHeight
-                    })
-                """
-                )
-
-                # Check if viewport changed
-                if current_viewport != last_viewport:
-                    last_viewport = current_viewport
-                    consecutive_same_count = 0
-
-                    print(
-                        f"[PYTHON] Viewport: {current_viewport['width']}x{current_viewport['height']}"
+                # Check if page is still alive
+                if self.page is None or self.page.is_closed():
+                    print("[PYTHON] Page closed, signaling exit")
+                    self._should_exit.set()
+                    return
+
+                # Update resize tracking
+                result = await self.resize_tracker.update()
+
+                if result is not None:
+                    assert isinstance(result, Exception)
+                    # An exception occurred in resize tracking
+                    error_message = str(result)
+                    warnings.warn(f"[PYTHON] Error in resize tracking: {error_message}")
+
+                    # Be EXTREMELY conservative about browser close detection
+                    # Only trigger shutdown on very specific errors that definitively indicate browser closure
+                    browser_definitely_closed = any(
+                        phrase in error_message.lower()
+                        for phrase in [
+                            "browser has been closed",
+                            "target closed",
+                            "connection closed",
+                            "target page, probably because the page has been closed",
+                            "page has been closed",
+                            "browser context has been closed",
+                        ]
                     )
 
-                    # Try to get window outer dimensions for context
+                    # Also check actual browser state before deciding to shut down
+                    browser_state_indicates_closed = False
                     try:
-                        window_info = await self.page.evaluate(
-                            """
-                        () => ({
-                            outerWidth: window.outerWidth,
-                            outerHeight: window.outerHeight,
-                            screenX: window.screenX,
-                            screenY: window.screenY
-                        })
-                    """
-                        )
-
-                        print(
-                            f"[PYTHON] Window: {window_info['outerWidth']}x{window_info['outerHeight']} at ({window_info['screenX']}, {window_info['screenY']})"
-                        )
-
-                    except Exception as e:
+                        if self.browser and hasattr(self.browser, "is_closed"):
+                            browser_state_indicates_closed = self.browser.is_closed()
+                        elif self.context and hasattr(self.context, "closed"):
+                            browser_state_indicates_closed = self.context.closed
+                    except Exception:
+                        # If we can't check the state, don't assume it's closed
                         warnings.warn(
-                            f"[PYTHON] Could not get browser window info: {e}. Assuming browser is not closed."
+                            f"[PYTHON] Could not check browser state: {result}. Assuming browser is not closed."
                         )
-                        pass
-
-                else:
-                    consecutive_same_count += 1
-                    if consecutive_same_count >= max_consecutive_same:
-                        # Viewport hasn't changed for a while, reduce polling frequency
-                        await asyncio.sleep(2.0)
-                        consecutive_same_count = 0
-
-                # Get the browser window information periodically
-                try:
-                    browser_info = await self.page.evaluate(
-                        """
-                        () => {
-                            return {
-                                userAgent: navigator.userAgent,
-                                platform: navigator.platform,
-                                cookieEnabled: navigator.cookieEnabled,
-                                language: navigator.language
-                            };
-                        }
-                    """
-                    )
-
-                    if browser_info:
-                        pass  # We have browser info, but don't need to print it constantly
+                        browser_state_indicates_closed = False
+
+                    if browser_definitely_closed or browser_state_indicates_closed:
+                        if browser_definitely_closed:
+                            print(
+                                f'[PYTHON] Browser has been closed because "{error_message}" matched one of the error phrases or browser state indicates closed, shutting down gracefully...'
+                            )
+                        elif browser_state_indicates_closed:
+                            print(
+                                "[PYTHON] Browser state indicates closed, shutting down gracefully..."
+                            )
+                        self._should_exit.set()
+                        return
                     else:
-                        print("[PYTHON] Could not get browser window info")
-
-                except Exception as e:
-                    print(f"[PYTHON] Could not get browser info: {e}")
+                        # For other errors, just log and continue - don't shut down
+                        print(
+                            f"[PYTHON] Recoverable error in resize tracking: {result}"
+                        )
+                        # Add a small delay to prevent tight error loops
+                        await asyncio.sleep(1.0)
 
             except Exception as e:
                 error_message = str(e)
-                warnings.warn(f"[PYTHON] Error in browser tracking: {error_message}")
-                # Be EXTREMELY conservative about browser close detection
-                # Only trigger shutdown on very specific errors that definitively indicate browser closure
-                browser_definitely_closed = any(
-                    phrase in error_message.lower()
-                    for phrase in [
-                        "browser has been closed",
-                        "target closed",
-                        "connection closed",
-                        "target page, probably because the page has been closed",
-                        # "execution context was destroyed",
-                        "page has been closed",
-                        "browser context has been closed",
-                    ]
+                warnings.warn(
+                    f"[PYTHON] Unexpected error in browser tracking loop: {error_message}"
                 )
+                # Add a small delay to prevent tight error loops
+                await asyncio.sleep(1.0)
 
-                # Also check actual browser state before deciding to shut down
-                browser_state_indicates_closed = False
-                try:
-                    if self.browser and hasattr(self.browser, "is_closed"):
-                        browser_state_indicates_closed = self.browser.is_closed()
-                    elif self.context and hasattr(self.context, "closed"):
-                        browser_state_indicates_closed = self.context.closed
-                except Exception:
-                    # If we can't check the state, don't assume it's closed
-                    warnings.warn(
-                        f"[PYTHON] Could not check browser state: {e}. Assuming browser is not closed."
-                    )
-                    browser_state_indicates_closed = False
-
-                if browser_definitely_closed or browser_state_indicates_closed:
-                    if browser_definitely_closed:
-                        print(
-                            f'[PYTHON] Browser has been closed because "{error_message}" matched one of the error phrases or browser state indicates closed, shutting down gracefully...'
-                        )
-                    elif browser_state_indicates_closed:
-                        print(
-                            "[PYTHON] Browser state indicates closed, shutting down gracefully..."
-                        )
-                    self._should_exit.set()
-                    break
-                else:
-                    # For other errors, just log and continue - don't shut down
-                    print(f"[PYTHON] Recoverable error in browser tracking: {e}")
-                    # Add a small delay to prevent tight error loops
-                    await asyncio.sleep(1.0)
-                    continue
         warnings.warn("[PYTHON] Browser tracking loop exited.")
 
     async def wait_for_close(self) -> None:
@@ -445,6 +397,8 @@ class PlaywrightBrowser:
         self._should_exit.set()
 
         try:
+            # Clean up resize tracker
+            self.resize_tracker = None
 
             if self.page:
                 await self.page.close()
@@ -487,6 +441,7 @@ class PlaywrightBrowser:
             _thread.interrupt_main()
         except Exception as e:
             print(f"[PYTHON] Error closing Playwright browser: {e}")
+            self._should_exit.set()
 
 
 def run_playwright_browser(

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"