Merge branch 'main' of https://github.com/neoncube2/playwright-python

Author: neoncube2

.github/workflows/trigger_internal_tests.yml

@@ -11,7 +11,7 @@ jobs:
     name: "trigger"
     runs-on: ubuntu-24.04
     steps:
-    - uses: actions/create-github-app-token@v1
+    - uses: actions/create-github-app-token@v2
       id: app-token
       with:
         app-id: ${{ vars.PLAYWRIGHT_APP_ID }}

README.md

@@ -4,9 +4,9 @@ Playwright is a Python library to automate [Chromium](https://www.chromium.org/H
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->134.0.6998.35<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->136.0.7103.25<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | WebKit <!-- GEN:webkit-version -->18.4<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->135.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->137.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 ## Documentation
 

local-requirements.txt

@@ -4,19 +4,19 @@ build==1.2.2.post1
 flake8==7.2.0
 mypy==1.15.0
 objgraph==3.6.2
-Pillow==11.1.0
+Pillow==11.2.1
 pixelmatch==0.3.0
 pre-commit==3.5.0
 pyOpenSSL==25.0.0
 pytest==8.3.5
 pytest-asyncio==0.26.0
-pytest-cov==6.0.0
-pytest-repeat==0.9.3
+pytest-cov==6.1.1
+pytest-repeat==0.9.4
 pytest-rerunfailures==15.0
 pytest-timeout==2.3.1
 pytest-xdist==3.6.1
 requests==2.32.3
 service_identity==24.2.0
 twisted==24.11.0
 types-pyOpenSSL==24.1.0.20240722
-types-requests==2.32.0.20250306
+types-requests==2.32.0.20250328

playwright/_impl/_assertions.py

@@ -300,6 +300,45 @@ async def not_to_have_class(
         __tracebackhide__ = True
         await self._not.to_have_class(expected, timeout)
 
+    async def to_contain_class(
+        self,
+        expected: Union[
+            Sequence[str],
+            str,
+        ],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        if isinstance(expected, collections.abc.Sequence) and not isinstance(
+            expected, str
+        ):
+            expected_text = to_expected_text_values(expected)
+            await self._expect_impl(
+                "to.contain.class.array",
+                FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+                expected,
+                "Locator expected to contain class names",
+            )
+        else:
+            expected_text = to_expected_text_values([expected])
+            await self._expect_impl(
+                "to.contain.class",
+                FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+                expected,
+                "Locator expected to contain class",
+            )
+
+    async def not_to_contain_class(
+        self,
+        expected: Union[
+            Sequence[str],
+            str,
+        ],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_contain_class(expected, timeout)
+
     async def to_have_count(
         self,
         count: int,

playwright/_impl/_fetch.py

@@ -74,6 +74,7 @@ async def new_context(
         storageState: Union[StorageState, str, Path] = None,
         clientCertificates: List[ClientCertificate] = None,
         failOnStatusCode: bool = None,
+        maxRedirects: int = None,
     ) -> "APIRequestContext":
         params = locals_to_params(locals())
         if "storageState" in params:

playwright/_impl/_glob.py

@@ -11,13 +11,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import re
 
 #  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions#escaping
 escaped_chars = {"$", "^", "+", ".", "*", "(", ")", "|", "\\", "?", "{", "}", "[", "]"}
 
 
-def glob_to_regex(glob: str) -> "re.Pattern[str]":
+def glob_to_regex_pattern(glob: str) -> str:
     tokens = ["^"]
     in_group = False
 
@@ -46,23 +45,20 @@ def glob_to_regex(glob: str) -> "re.Pattern[str]":
             else:
                 tokens.append("([^/]*)")
         else:
-            if c == "?":
-                tokens.append(".")
-            elif c == "[":
-                tokens.append("[")
-            elif c == "]":
-                tokens.append("]")
-            elif c == "{":
+            if c == "{":
                 in_group = True
                 tokens.append("(")
             elif c == "}":
                 in_group = False
                 tokens.append(")")
-            elif c == "," and in_group:
-                tokens.append("|")
+            elif c == ",":
+                if in_group:
+                    tokens.append("|")
+                else:
+                    tokens.append("\\" + c)
             else:
                 tokens.append("\\" + c if c in escaped_chars else c)
         i += 1
 
     tokens.append("$")
-    return re.compile("".join(tokens))
+    return "".join(tokens)

playwright/_impl/_helper.py

@@ -44,7 +44,7 @@
     is_target_closed_error,
     rewrite_error,
 )
-from playwright._impl._glob import glob_to_regex
+from playwright._impl._glob import glob_to_regex_pattern
 from playwright._impl._greenlets import RouteGreenlet
 from playwright._impl._str_utils import escape_regex_flags
 
@@ -144,31 +144,103 @@ class FrameNavigatedEvent(TypedDict):
 
 
 def url_matches(
-    base_url: Optional[str], url_string: str, match: Optional[URLMatch]
+    base_url: Optional[str],
+    url_string: str,
+    match: Optional[URLMatch],
+    websocket_url: bool = None,
 ) -> bool:
     if not match:
         return True
-    if isinstance(match, str) and match[0] != "*":
-        # Allow http(s) baseURL to match ws(s) urls.
-        if (
-            base_url
-            and re.match(r"^https?://", base_url)
-            and re.match(r"^wss?://", url_string)
-        ):
-            base_url = re.sub(r"^http", "ws", base_url)
-        if base_url:
-            match = urljoin(base_url, match)
-        parsed = urlparse(match)
-        if parsed.path == "":
-            parsed = parsed._replace(path="/")
-            match = parsed.geturl()
     if isinstance(match, str):
-        match = glob_to_regex(match)
+        match = re.compile(
+            resolve_glob_to_regex_pattern(base_url, match, websocket_url)
+        )
     if isinstance(match, Pattern):
         return bool(match.search(url_string))
     return match(url_string)
 
 
+def resolve_glob_to_regex_pattern(
+    base_url: Optional[str], glob: str, websocket_url: bool = None
+) -> str:
+    if websocket_url:
+        base_url = to_websocket_base_url(base_url)
+    glob = resolve_glob_base(base_url, glob)
+    return glob_to_regex_pattern(glob)
+
+
+def to_websocket_base_url(base_url: Optional[str]) -> Optional[str]:
+    if base_url is not None and re.match(r"^https?://", base_url):
+        base_url = re.sub(r"^http", "ws", base_url)
+    return base_url
+
+
+def resolve_glob_base(base_url: Optional[str], match: str) -> str:
+    if match[0] == "*":
+        return match
+
+    token_map: Dict[str, str] = {}
+
+    def map_token(original: str, replacement: str) -> str:
+        if len(original) == 0:
+            return ""
+        token_map[replacement] = original
+        return replacement
+
+    # Escaped `\\?` behaves the same as `?` in our glob patterns.
+    match = match.replace(r"\\?", "?")
+    # Glob symbols may be escaped in the URL and some of them such as ? affect resolution,
+    # so we replace them with safe components first.
+    processed_parts = []
+    for index, token in enumerate(match.split("/")):
+        if token in (".", "..", ""):
+            processed_parts.append(token)
+            continue
+        # Handle special case of http*://, note that the new schema has to be
+        # a web schema so that slashes are properly inserted after domain.
+        if index == 0 and token.endswith(":"):
+            # Using a simple replacement for the scheme part
+            processed_parts.append(map_token(token, "http:"))
+            continue
+        question_index = token.find("?")
+        if question_index == -1:
+            processed_parts.append(map_token(token, f"$_{index}_$"))
+        else:
+            new_prefix = map_token(token[:question_index], f"$_{index}_$")
+            new_suffix = map_token(token[question_index:], f"?$_{index}_$")
+            processed_parts.append(new_prefix + new_suffix)
+
+    relative_path = "/".join(processed_parts)
+    resolved_url = urljoin(base_url if base_url is not None else "", relative_path)
+
+    for replacement, original in token_map.items():
+        resolved_url = resolved_url.replace(replacement, original, 1)
+
+    return ensure_trailing_slash(resolved_url)
+
+
+# In Node.js, new URL('http://localhost') returns 'http://localhost/'.
+# To ensure the same url matching behavior, do the same.
+def ensure_trailing_slash(url: str) -> str:
+    split = url.split("://", maxsplit=1)
+    if len(split) == 2:
+        # URL parser doesn't like strange/unknown schemes, so we replace it for parsing, then put it back
+        parsable_url = "http://" + split[1]
+    else:
+        # Given current rules, this should never happen _and_ still be a valid matcher. We require the protocol to be part of the match,
+        # so either the user is using a glob that starts with "*" (and none of this code is running), or the user actually has `something://` in `match`
+        parsable_url = url
+    parsed = urlparse(parsable_url, allow_fragments=True)
+    if len(split) == 2:
+        # Replace the scheme that we removed earlier
+        parsed = parsed._replace(scheme=split[0])
+    if parsed.path == "":
+        parsed = parsed._replace(path="/")
+        url = parsed.geturl()
+
+    return url
+
+
 class HarLookupResult(TypedDict, total=False):
     action: Literal["error", "redirect", "fulfill", "noentry"]
     message: Optional[str]

playwright/_impl/_js_handle.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import base64
 import collections.abc
 import datetime
 import math
+import struct
 import traceback
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
@@ -260,6 +262,56 @@ def parse_value(value: Any, refs: Optional[Dict[int, Any]] = None) -> Any:
 
         if "b" in value:
             return value["b"]
+
+        if "ta" in value:
+            encoded_bytes = value["ta"]["b"]
+            decoded_bytes = base64.b64decode(encoded_bytes)
+            array_type = value["ta"]["k"]
+            if array_type == "i8":
+                word_size = 1
+                fmt = "b"
+            elif array_type == "ui8" or array_type == "ui8c":
+                word_size = 1
+                fmt = "B"
+            elif array_type == "i16":
+                word_size = 2
+                fmt = "h"
+            elif array_type == "ui16":
+                word_size = 2
+                fmt = "H"
+            elif array_type == "i32":
+                word_size = 4
+                fmt = "i"
+            elif array_type == "ui32":
+                word_size = 4
+                fmt = "I"
+            elif array_type == "f32":
+                word_size = 4
+                fmt = "f"
+            elif array_type == "f64":
+                word_size = 8
+                fmt = "d"
+            elif array_type == "bi64":
+                word_size = 8
+                fmt = "q"
+            elif array_type == "bui64":
+                word_size = 8
+                fmt = "Q"
+            else:
+                raise ValueError(f"Unsupported array type: {array_type}")
+
+            byte_len = len(decoded_bytes)
+            if byte_len % word_size != 0:
+                raise ValueError(
+                    f"Decoded bytes length {byte_len} is not a multiple of word size {word_size}"
+                )
+
+            if byte_len == 0:
+                return []
+            array_len = byte_len // word_size
+            # "<" denotes little-endian
+            format_string = f"<{array_len}{fmt}"
+            return list(struct.unpack(format_string, decoded_bytes))
     return value
 
 

playwright/_impl/_locator.py

@@ -540,7 +540,7 @@ async def screenshot(
             ),
         )
 
-    async def aria_snapshot(self, timeout: float = None) -> str:
+    async def aria_snapshot(self, timeout: float = None, ref: bool = None) -> str:
         return await self._frame._channel.send(
             "ariaSnapshot",
             {

playwright/_impl/_network.py

@@ -754,7 +754,7 @@ def prepare_interception_patterns(
         return patterns
 
     def matches(self, ws_url: str) -> bool:
-        return url_matches(self._base_url, ws_url, self.url)
+        return url_matches(self._base_url, ws_url, self.url, True)
 
     async def handle(self, websocket_route: "WebSocketRoute") -> None:
         coro_or_future = self.handler(websocket_route)