percy-playwright 1.0.0__tar.gz

percy_playwright-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Percy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

percy_playwright-1.0.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.1
+Name: percy-playwright
+Version: 1.0.0
+Summary: Python client for visual testing with Percy
+Home-page: https://github.com/percy/percy-playwright-python
+Author: Perceptual Inc.
+Author-email: team@percy.io
+License: MIT
+Keywords: percy visual testing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: playwright>=1.28.0
+Requires-Dist: requests==2.*
+
+# Percy playwright python
+![Test](https://github.com/percy/percy-playwright-python/workflows/Test/badge.svg)
+
+[Percy](https://percy.io) visual testing for Python Playwright.
+
+## Installation
+
+npm install `@percy/cli`:
+
+```sh-session
+$ npm install --save-dev @percy/cli
+```
+
+pip install Percy playwright package:
+
+```ssh-session
+$ pip install percy-playwright
+```
+
+## Usage
+
+This is an example test using the `percy_snapshot` function.
+
+``` python
+from percy import percy_snapshot
+
+with sync_playwright() as playwright:
+  browser = playwright.chromium.connect()
+  page = browser.new_page()
+  page.goto('http://example.com')
+  ​
+  # take a snapshot
+  percy_snapshot(browser, 'Python example')
+```
+
+Running the test above normally will result in the following log:
+
+```sh-session
+[percy] Percy is not running, disabling snapshots
+```
+
+When running with [`percy
+exec`](https://github.com/percy/cli/tree/master/packages/cli-exec#percy-exec), and your project's
+`PERCY_TOKEN`, a new Percy build will be created and snapshots will be uploaded to your project.
+
+```sh-session
+$ export PERCY_TOKEN=[your-project-token]
+$ percy exec -- [python test command]
+[percy] Percy has started!
+[percy] Created build #1: https://percy.io/[your-project]
+[percy] Snapshot taken "Python example"
+[percy] Stopping percy...
+[percy] Finalized build #1: https://percy.io/[your-project]
+[percy] Done!
+```
+
+## Configuration
+
+`percy_snapshot(page, name[, **kwargs])`
+
+- `page` (**required**) - A playwright page instance
+- `name` (**required**) - The snapshot name; must be unique to each snapshot
+- `**kwargs` - [See per-snapshot configuration options](https://www.browserstack.com/docs/percy/take-percy-snapshots/overview#per-snapshot-configuration)
+
+
+## Percy on Automate
+
+## Usage
+
+``` python
+from playwright.sync_api import sync_playwright
+from percy import percy_screenshot, percy_snapshot
+
+desired_cap = {
+  'browser': 'chrome',
+  'browser_version': 'latest',
+  'os': 'osx',
+  'os_version': 'ventura',
+  'name': 'Percy Playwright PoA Demo',
+  'build': 'percy-playwright-python-tutorial',
+  'browserstack.username': 'username',
+  'browserstack.accessKey': 'accesskey'
+}
+
+with sync_playwright() as playwright:
+  cdpUrl = 'wss://cdp.browserstack.com/playwright?caps=' + urllib.parse.quote(json.dumps(desired_cap))
+  browser = playwright.chromium.connect(cdpUrl)
+  page = browser.new_page()
+  page.goto("https://percy.io/")
+  percy_screenshot(page, name = "Screenshot 1")
+```
+# take a snapshot
+```python
+percy_screenshot(page, name = 'Screenshot 1')
+```
+
+- `page` (**required**) - A Playwright page instance
+- `name` (**required**) - The screenshot name; must be unique to each screenshot
+- `options` (**optional**) - There are various options supported by percy_screenshot to server further functionality.
+    - `sync` - Boolean value by default it falls back to `false`, Gives the processed result around screenshot [From CLI v1.28.8]
+    - `full_page` - Boolean value by default it falls back to `false`, Takes full page screenshot [From CLI v1.28.8]
+    - `freeze_animated_image` - Boolean value by default it falls back to `false`, you can pass `true` and percy will freeze image based animations.
+    - `freeze_image_by_selectors` -List of selectors. Images will be freezed which are passed using selectors. For this to work `freeze_animated_image` must be set to true.
+    - `freeze_image_by_xpaths` - List of xpaths. Images will be freezed which are passed using xpaths. For this to work `freeze_animated_image` must be set to true.
+    - `percy_css` - Custom CSS to be added to DOM before the screenshot being taken. Note: This gets removed once the screenshot is taken.
+    - `ignore_region_xpaths` - List of xpaths. elements in the DOM can be ignored using xpath
+    - `ignore_region_selectors` - List of selectors. elements in the DOM can be ignored using selectors.
+    - `custom_ignore_regions` -  List of custom objects. elements can be ignored using custom boundaries. Just passing a simple object for it like below.
+      - example: ```{"top": 10, "right": 10, "bottom": 120, "left": 10}```
+      - In above example it will draw rectangle of ignore region as per given coordinates.
+          - `top` (int): Top coordinate of the ignore region.
+          - `bottom` (int): Bottom coordinate of the ignore region.
+          - `left` (int): Left coordinate of the ignore region.
+          - `right` (int): Right coordinate of the ignore region.
+    - `consider_region_xpaths` - List of xpaths. elements in the DOM can be considered for diffing and will be ignored by Intelli Ignore using xpaths.
+    - `consider_region_selectors` - List of selectors. elements in the DOM can be considered for diffing and will be ignored by Intelli Ignore using selectors.
+    - `custom_consider_regions` - List of custom objects. elements can be considered for diffing and will be ignored by Intelli Ignore using custom boundaries
+      - example:```{"top": 10, "right": 10, "bottom": 120, "left": 10}```
+      - In above example it will draw rectangle of consider region will be drawn.
+      - Parameters:
+        - `top` (int): Top coordinate of the consider region.
+        - `bottom` (int): Bottom coordinate of the consider region.
+        - `left` (int): Left coordinate of the consider region.
+        - `right` (int): Right coordinate of the consider region.
+
+
+### Creating Percy on automate build
+Note: Automate Percy Token starts with `auto` keyword. The command can be triggered using `exec` keyword.
+
+```sh-session
+$ export PERCY_TOKEN=[your-project-token]
+$ percy exec -- [python test command]
+[percy] Percy has started!
+[percy] [Python example] : Starting automate screenshot ...
+[percy] Screenshot taken "Python example"
+[percy] Stopping percy...
+[percy] Finalized build #1: https://percy.io/[your-project]
+[percy] Done!
+```
+
+Refer to docs here: [Percy on Automate](https://www.browserstack.com/docs/percy/integrate/functional-and-visual)

percy_playwright-1.0.0/README.md

@@ -0,0 +1,141 @@
+# Percy playwright python
+![Test](https://github.com/percy/percy-playwright-python/workflows/Test/badge.svg)
+
+[Percy](https://percy.io) visual testing for Python Playwright.
+
+## Installation
+
+npm install `@percy/cli`:
+
+```sh-session
+$ npm install --save-dev @percy/cli
+```
+
+pip install Percy playwright package:
+
+```ssh-session
+$ pip install percy-playwright
+```
+
+## Usage
+
+This is an example test using the `percy_snapshot` function.
+
+``` python
+from percy import percy_snapshot
+
+with sync_playwright() as playwright:
+  browser = playwright.chromium.connect()
+  page = browser.new_page()
+  page.goto('http://example.com')
+  ​
+  # take a snapshot
+  percy_snapshot(browser, 'Python example')
+```
+
+Running the test above normally will result in the following log:
+
+```sh-session
+[percy] Percy is not running, disabling snapshots
+```
+
+When running with [`percy
+exec`](https://github.com/percy/cli/tree/master/packages/cli-exec#percy-exec), and your project's
+`PERCY_TOKEN`, a new Percy build will be created and snapshots will be uploaded to your project.
+
+```sh-session
+$ export PERCY_TOKEN=[your-project-token]
+$ percy exec -- [python test command]
+[percy] Percy has started!
+[percy] Created build #1: https://percy.io/[your-project]
+[percy] Snapshot taken "Python example"
+[percy] Stopping percy...
+[percy] Finalized build #1: https://percy.io/[your-project]
+[percy] Done!
+```
+
+## Configuration
+
+`percy_snapshot(page, name[, **kwargs])`
+
+- `page` (**required**) - A playwright page instance
+- `name` (**required**) - The snapshot name; must be unique to each snapshot
+- `**kwargs` - [See per-snapshot configuration options](https://www.browserstack.com/docs/percy/take-percy-snapshots/overview#per-snapshot-configuration)
+
+
+## Percy on Automate
+
+## Usage
+
+``` python
+from playwright.sync_api import sync_playwright
+from percy import percy_screenshot, percy_snapshot
+
+desired_cap = {
+  'browser': 'chrome',
+  'browser_version': 'latest',
+  'os': 'osx',
+  'os_version': 'ventura',
+  'name': 'Percy Playwright PoA Demo',
+  'build': 'percy-playwright-python-tutorial',
+  'browserstack.username': 'username',
+  'browserstack.accessKey': 'accesskey'
+}
+
+with sync_playwright() as playwright:
+  cdpUrl = 'wss://cdp.browserstack.com/playwright?caps=' + urllib.parse.quote(json.dumps(desired_cap))
+  browser = playwright.chromium.connect(cdpUrl)
+  page = browser.new_page()
+  page.goto("https://percy.io/")
+  percy_screenshot(page, name = "Screenshot 1")
+```
+# take a snapshot
+```python
+percy_screenshot(page, name = 'Screenshot 1')
+```
+
+- `page` (**required**) - A Playwright page instance
+- `name` (**required**) - The screenshot name; must be unique to each screenshot
+- `options` (**optional**) - There are various options supported by percy_screenshot to server further functionality.
+    - `sync` - Boolean value by default it falls back to `false`, Gives the processed result around screenshot [From CLI v1.28.8]
+    - `full_page` - Boolean value by default it falls back to `false`, Takes full page screenshot [From CLI v1.28.8]
+    - `freeze_animated_image` - Boolean value by default it falls back to `false`, you can pass `true` and percy will freeze image based animations.
+    - `freeze_image_by_selectors` -List of selectors. Images will be freezed which are passed using selectors. For this to work `freeze_animated_image` must be set to true.
+    - `freeze_image_by_xpaths` - List of xpaths. Images will be freezed which are passed using xpaths. For this to work `freeze_animated_image` must be set to true.
+    - `percy_css` - Custom CSS to be added to DOM before the screenshot being taken. Note: This gets removed once the screenshot is taken.
+    - `ignore_region_xpaths` - List of xpaths. elements in the DOM can be ignored using xpath
+    - `ignore_region_selectors` - List of selectors. elements in the DOM can be ignored using selectors.
+    - `custom_ignore_regions` -  List of custom objects. elements can be ignored using custom boundaries. Just passing a simple object for it like below.
+      - example: ```{"top": 10, "right": 10, "bottom": 120, "left": 10}```
+      - In above example it will draw rectangle of ignore region as per given coordinates.
+          - `top` (int): Top coordinate of the ignore region.
+          - `bottom` (int): Bottom coordinate of the ignore region.
+          - `left` (int): Left coordinate of the ignore region.
+          - `right` (int): Right coordinate of the ignore region.
+    - `consider_region_xpaths` - List of xpaths. elements in the DOM can be considered for diffing and will be ignored by Intelli Ignore using xpaths.
+    - `consider_region_selectors` - List of selectors. elements in the DOM can be considered for diffing and will be ignored by Intelli Ignore using selectors.
+    - `custom_consider_regions` - List of custom objects. elements can be considered for diffing and will be ignored by Intelli Ignore using custom boundaries
+      - example:```{"top": 10, "right": 10, "bottom": 120, "left": 10}```
+      - In above example it will draw rectangle of consider region will be drawn.
+      - Parameters:
+        - `top` (int): Top coordinate of the consider region.
+        - `bottom` (int): Bottom coordinate of the consider region.
+        - `left` (int): Left coordinate of the consider region.
+        - `right` (int): Right coordinate of the consider region.
+
+
+### Creating Percy on automate build
+Note: Automate Percy Token starts with `auto` keyword. The command can be triggered using `exec` keyword.
+
+```sh-session
+$ export PERCY_TOKEN=[your-project-token]
+$ percy exec -- [python test command]
+[percy] Percy has started!
+[percy] [Python example] : Starting automate screenshot ...
+[percy] Screenshot taken "Python example"
+[percy] Stopping percy...
+[percy] Finalized build #1: https://percy.io/[your-project]
+[percy] Done!
+```
+
+Refer to docs here: [Percy on Automate](https://www.browserstack.com/docs/percy/integrate/functional-and-visual)

percy_playwright-1.0.0/percy/__init__.py

@@ -0,0 +1,22 @@
+from percy.version import __version__
+from percy.screenshot import percy_automate_screenshot
+
+# import snapshot command
+try:
+    from percy.screenshot import percy_snapshot
+except ImportError:
+
+    def percy_snapshot(page, *a, **kw):
+        raise ModuleNotFoundError(
+            "[percy] `percy-playwright-python` package is not installed, "
+            "please install it to use percy_snapshot command"
+        )
+
+
+# for better backwards compatibility
+def percySnapshot(browser, *a, **kw):
+    return percy_snapshot(page=browser, *a, **kw)
+
+
+def percy_screenshot(page, *a, **kw):
+    return percy_automate_screenshot(page, *a, **kw)

percy_playwright-1.0.0/percy/cache.py

@@ -0,0 +1,42 @@
+import time
+
+
+class Cache:
+    CACHE = {}
+    CACHE_TIMEOUT = 5 * 60  # 300 seconds
+    TIMEOUT_KEY = "last_access_time"
+
+    # Caching Keys
+    session_details = "session_details"
+
+    @classmethod
+    def check_types(cls, session_id, property):
+        if not isinstance(session_id, str):
+            raise TypeError("Argument session_id should be string")
+        if not isinstance(property, str):
+            raise TypeError("Argument property should be string")
+
+    @classmethod
+    def set_cache(cls, session_id, property, value):
+        cls.check_types(session_id, property)
+        session = cls.CACHE.get(session_id, {})
+        session[cls.TIMEOUT_KEY] = time.time()
+        session[property] = value
+        cls.CACHE[session_id] = session
+
+    @classmethod
+    def get_cache(cls, session_id, property):
+        cls.cleanup_cache()
+        cls.check_types(session_id, property)
+        session = cls.CACHE.get(session_id, {})
+        return session.get(property, None)
+
+    @classmethod
+    def cleanup_cache(cls):
+        now = time.time()
+        for session_id, session in cls.CACHE.items():
+            timestamp = session[cls.TIMEOUT_KEY]
+            if now - timestamp >= cls.CACHE_TIMEOUT:
+                cls.CACHE[session_id] = {
+                    cls.session_details: session[cls.session_details]
+                }

percy_playwright-1.0.0/percy/page_metadata.py

@@ -0,0 +1,44 @@
+# pylint: disable=protected-access
+import json
+from percy.cache import Cache
+
+
+class PageMetaData:
+    def __init__(self, page):
+        self.page = page
+
+    def __fetch_guid(self, obj):
+        return obj._impl_obj._guid
+
+    @property
+    def framework(self):
+        return "playwright"
+
+    @property
+    def page_guid(self):
+        return self.__fetch_guid(self.page)
+
+    @property
+    def frame_guid(self):
+        return self.__fetch_guid(self.page.main_frame)
+
+    @property
+    def browser_guid(self):
+        return self.__fetch_guid(self.page.context.browser)
+
+    @property
+    def session_details(self):
+        session_details = Cache.get_cache(self.browser_guid, Cache.session_details)
+        if session_details is None:
+            session_details = json.loads(
+                self.page.evaluate(
+                    "_ => {}", 'browserstack_executor: {"action": "getSessionDetails"}'
+                )
+            )
+            Cache.set_cache(self.browser_guid, Cache.session_details, session_details)
+            return session_details
+        return session_details
+
+    @property
+    def automate_session_id(self):
+        return self.session_details.get("hashed_id")

percy_playwright-1.0.0/percy/screenshot.py

@@ -0,0 +1,168 @@
+import os
+import json
+import platform
+from functools import lru_cache
+import requests
+
+from playwright._repo_version import version as PLAYWRIGHT_VERSION
+from percy.version import __version__ as SDK_VERSION
+from percy.page_metadata import PageMetaData
+
+# Collect client environment information
+CLIENT_INFO = "percy-playwright-python/" + SDK_VERSION
+ENV_INFO = ["playwright/" + PLAYWRIGHT_VERSION, "python/" + platform.python_version()]
+
+# Maybe get the CLI API address from the environment
+PERCY_CLI_API = os.environ.get("PERCY_CLI_API") or "http://localhost:5338"
+PERCY_DEBUG = os.environ.get("PERCY_LOGLEVEL") == "debug"
+
+# for logging
+LABEL = "[\u001b[35m" + ("percy:python" if PERCY_DEBUG else "percy") + "\u001b[39m]"
+
+
+# Check if Percy is enabled, caching the result so it is only checked once
+@lru_cache(maxsize=None)
+def is_percy_enabled():
+    try:
+        response = requests.get(f"{PERCY_CLI_API}/percy/healthcheck", timeout=30)
+        response.raise_for_status()
+        data = response.json()
+        session_type = data.get("type", None)
+
+        if not data["success"]:
+            raise Exception(data["error"])
+        version = response.headers.get("x-percy-core-version")
+
+        if not version:
+            print(
+                f"{LABEL} You may be using @percy/agent "
+                "which is no longer supported by this SDK. "
+                "Please uninstall @percy/agent and install @percy/cli instead. "
+                "https://www.browserstack.com/docs/percy/migration/migrate-to-cli"
+            )
+            return False
+
+        if version.split(".")[0] != "1":
+            print(f"{LABEL} Unsupported Percy CLI version, {version}")
+            return False
+
+        return session_type
+    except Exception as e:
+        print(f"{LABEL} Percy is not running, disabling snapshots")
+        if PERCY_DEBUG:
+            print(f"{LABEL} {e}")
+        return False
+
+
+# Fetch the @percy/dom script, caching the result so it is only fetched once
+@lru_cache(maxsize=None)
+def fetch_percy_dom():
+    response = requests.get(f"{PERCY_CLI_API}/percy/dom.js", timeout=30)
+    response.raise_for_status()
+    return response.text
+
+
+# Take a DOM snapshot and post it to the snapshot endpoint
+def percy_snapshot(page, name, **kwargs):
+    session_type = is_percy_enabled()
+    if session_type is False:
+        return None  # Since session_type can be None for old CLI version
+    if session_type == "automate":
+        raise Exception(
+            "Invalid function call - "
+            "percy_snapshot(). "
+            "Please use percy_screenshot() function while using Percy with Automate. "
+            "For more information on usage of PercyScreenshot, "
+            "refer https://www.browserstack.com/docs/percy/integrate/functional-and-visual"
+        )
+
+    try:
+        # Inject the DOM serialization script
+        # print(fetch_percy_dom())
+        page.evaluate(fetch_percy_dom())
+
+        # Serialize and capture the DOM
+        dom_snapshot_script = f"PercyDOM.serialize({json.dumps(kwargs)})"
+
+        # Return the serialized DOM Snapshot
+        dom_snapshot = page.evaluate(dom_snapshot_script)
+
+        # Post the DOM to the snapshot endpoint with snapshot options and other info
+        response = requests.post(
+            f"{PERCY_CLI_API}/percy/snapshot",
+            json={
+                **kwargs,
+                **{
+                    "client_info": CLIENT_INFO,
+                    "environment_info": ENV_INFO,
+                    "dom_snapshot": dom_snapshot,
+                    "url": page.url,
+                    "name": name,
+                },
+            },
+            timeout=600,
+        )
+
+        # Handle errors
+        response.raise_for_status()
+        data = response.json()
+
+        if not data["success"]:
+            raise Exception(data["error"])
+        return data.get("data", None)
+    except Exception as e:
+        print(f'{LABEL} Could not take DOM snapshot "{name}"')
+        print(f"{LABEL} {e}")
+        return None
+
+
+def percy_automate_screenshot(page, name, options=None, **kwargs):
+    session_type = is_percy_enabled()
+    if session_type is False:
+        return None  # Since session_type can be None for old CLI version
+    if session_type == "web":
+        raise Exception(
+            "Invalid function call - "
+            "percy_screenshot(). Please use percy_snapshot() function for taking screenshot. "
+            "percy_screenshot() should be used only while using Percy with Automate. "
+            "For more information on usage of percy_snapshot(), "
+            "refer doc for your language https://www.browserstack.com/docs/percy/integrate/overview"
+        )
+
+    if options is None:
+        options = {}
+
+    try:
+        metadata = PageMetaData(page)
+
+        # Post to automateScreenshot endpoint with page options and other info
+        response = requests.post(
+            f"{PERCY_CLI_API}/percy/automateScreenshot",
+            json={
+                **kwargs,
+                **{
+                    "client_info": CLIENT_INFO,
+                    "environment_info": ENV_INFO,
+                    "sessionId": metadata.automate_session_id,
+                    "pageGuid": metadata.page_guid,
+                    "frameGuid": metadata.frame_guid,
+                    "framework": metadata.framework,
+                    "snapshotName": name,
+                    "options": options,
+                },
+            },
+            timeout=600,
+        )
+
+        # Handle errors
+        response.raise_for_status()
+        data = response.json()
+
+        if not data["success"]:
+            raise Exception(data["error"])
+
+        return data.get("data", None)
+    except Exception as e:
+        print(f'{LABEL} Could not take Screenshot "{name}"')
+        print(f"{LABEL} {e}")
+        return None

percy_playwright-1.0.0/percy/version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

percy_playwright-1.0.0/percy_playwright.egg-info/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.1
+Name: percy-playwright
+Version: 1.0.0
+Summary: Python client for visual testing with Percy
+Home-page: https://github.com/percy/percy-playwright-python
+Author: Perceptual Inc.
+Author-email: team@percy.io
+License: MIT
+Keywords: percy visual testing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: playwright>=1.28.0
+Requires-Dist: requests==2.*
+
+# Percy playwright python
+![Test](https://github.com/percy/percy-playwright-python/workflows/Test/badge.svg)
+
+[Percy](https://percy.io) visual testing for Python Playwright.
+
+## Installation
+
+npm install `@percy/cli`:
+
+```sh-session
+$ npm install --save-dev @percy/cli
+```
+
+pip install Percy playwright package:
+
+```ssh-session
+$ pip install percy-playwright
+```
+
+## Usage
+
+This is an example test using the `percy_snapshot` function.
+
+``` python
+from percy import percy_snapshot
+
+with sync_playwright() as playwright:
+  browser = playwright.chromium.connect()
+  page = browser.new_page()
+  page.goto('http://example.com')
+  ​
+  # take a snapshot
+  percy_snapshot(browser, 'Python example')
+```
+
+Running the test above normally will result in the following log:
+
+```sh-session
+[percy] Percy is not running, disabling snapshots
+```
+
+When running with [`percy
+exec`](https://github.com/percy/cli/tree/master/packages/cli-exec#percy-exec), and your project's
+`PERCY_TOKEN`, a new Percy build will be created and snapshots will be uploaded to your project.
+
+```sh-session
+$ export PERCY_TOKEN=[your-project-token]
+$ percy exec -- [python test command]
+[percy] Percy has started!
+[percy] Created build #1: https://percy.io/[your-project]
+[percy] Snapshot taken "Python example"
+[percy] Stopping percy...
+[percy] Finalized build #1: https://percy.io/[your-project]
+[percy] Done!
+```
+
+## Configuration
+
+`percy_snapshot(page, name[, **kwargs])`
+
+- `page` (**required**) - A playwright page instance
+- `name` (**required**) - The snapshot name; must be unique to each snapshot
+- `**kwargs` - [See per-snapshot configuration options](https://www.browserstack.com/docs/percy/take-percy-snapshots/overview#per-snapshot-configuration)
+
+
+## Percy on Automate
+
+## Usage
+
+``` python
+from playwright.sync_api import sync_playwright
+from percy import percy_screenshot, percy_snapshot
+
+desired_cap = {
+  'browser': 'chrome',
+  'browser_version': 'latest',
+  'os': 'osx',
+  'os_version': 'ventura',
+  'name': 'Percy Playwright PoA Demo',
+  'build': 'percy-playwright-python-tutorial',
+  'browserstack.username': 'username',
+  'browserstack.accessKey': 'accesskey'
+}
+
+with sync_playwright() as playwright:
+  cdpUrl = 'wss://cdp.browserstack.com/playwright?caps=' + urllib.parse.quote(json.dumps(desired_cap))
+  browser = playwright.chromium.connect(cdpUrl)
+  page = browser.new_page()
+  page.goto("https://percy.io/")
+  percy_screenshot(page, name = "Screenshot 1")
+```
+# take a snapshot
+```python
+percy_screenshot(page, name = 'Screenshot 1')
+```
+
+- `page` (**required**) - A Playwright page instance
+- `name` (**required**) - The screenshot name; must be unique to each screenshot
+- `options` (**optional**) - There are various options supported by percy_screenshot to server further functionality.
+    - `sync` - Boolean value by default it falls back to `false`, Gives the processed result around screenshot [From CLI v1.28.8]
+    - `full_page` - Boolean value by default it falls back to `false`, Takes full page screenshot [From CLI v1.28.8]
+    - `freeze_animated_image` - Boolean value by default it falls back to `false`, you can pass `true` and percy will freeze image based animations.
+    - `freeze_image_by_selectors` -List of selectors. Images will be freezed which are passed using selectors. For this to work `freeze_animated_image` must be set to true.
+    - `freeze_image_by_xpaths` - List of xpaths. Images will be freezed which are passed using xpaths. For this to work `freeze_animated_image` must be set to true.
+    - `percy_css` - Custom CSS to be added to DOM before the screenshot being taken. Note: This gets removed once the screenshot is taken.
+    - `ignore_region_xpaths` - List of xpaths. elements in the DOM can be ignored using xpath
+    - `ignore_region_selectors` - List of selectors. elements in the DOM can be ignored using selectors.
+    - `custom_ignore_regions` -  List of custom objects. elements can be ignored using custom boundaries. Just passing a simple object for it like below.
+      - example: ```{"top": 10, "right": 10, "bottom": 120, "left": 10}```
+      - In above example it will draw rectangle of ignore region as per given coordinates.
+          - `top` (int): Top coordinate of the ignore region.
+          - `bottom` (int): Bottom coordinate of the ignore region.
+          - `left` (int): Left coordinate of the ignore region.
+          - `right` (int): Right coordinate of the ignore region.
+    - `consider_region_xpaths` - List of xpaths. elements in the DOM can be considered for diffing and will be ignored by Intelli Ignore using xpaths.
+    - `consider_region_selectors` - List of selectors. elements in the DOM can be considered for diffing and will be ignored by Intelli Ignore using selectors.
+    - `custom_consider_regions` - List of custom objects. elements can be considered for diffing and will be ignored by Intelli Ignore using custom boundaries
+      - example:```{"top": 10, "right": 10, "bottom": 120, "left": 10}```
+      - In above example it will draw rectangle of consider region will be drawn.
+      - Parameters:
+        - `top` (int): Top coordinate of the consider region.
+        - `bottom` (int): Bottom coordinate of the consider region.
+        - `left` (int): Left coordinate of the consider region.
+        - `right` (int): Right coordinate of the consider region.
+
+
+### Creating Percy on automate build
+Note: Automate Percy Token starts with `auto` keyword. The command can be triggered using `exec` keyword.
+
+```sh-session
+$ export PERCY_TOKEN=[your-project-token]
+$ percy exec -- [python test command]
+[percy] Percy has started!
+[percy] [Python example] : Starting automate screenshot ...
+[percy] Screenshot taken "Python example"
+[percy] Stopping percy...
+[percy] Finalized build #1: https://percy.io/[your-project]
+[percy] Done!
+```
+
+Refer to docs here: [Percy on Automate](https://www.browserstack.com/docs/percy/integrate/functional-and-visual)

percy_playwright-1.0.0/percy_playwright.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+setup.py
+percy/__init__.py
+percy/cache.py
+percy/page_metadata.py
+percy/screenshot.py
+percy/version.py
+percy_playwright.egg-info/PKG-INFO
+percy_playwright.egg-info/SOURCES.txt
+percy_playwright.egg-info/dependency_links.txt
+percy_playwright.egg-info/not-zip-safe
+percy_playwright.egg-info/requires.txt
+percy_playwright.egg-info/top_level.txt
+tests/test_cache.py
+tests/test_page_metadata.py
+tests/test_screenshot.py

percy_playwright-1.0.0/percy_playwright.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

percy_playwright-1.0.0/percy_playwright.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

percy_playwright-1.0.0/percy_playwright.egg-info/requires.txt

@@ -0,0 +1,2 @@
+playwright>=1.28.0
+requests==2.*

percy_playwright-1.0.0/percy_playwright.egg-info/top_level.txt

@@ -0,0 +1 @@
+percy

percy_playwright-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

percy_playwright-1.0.0/setup.py

@@ -0,0 +1,41 @@
+from setuptools import setup
+from os import path
+import percy
+
+# read the README for long_description
+cwd = path.abspath(path.dirname(__file__))
+with open(path.join(cwd, 'README.md'), encoding='utf-8') as f:
+    long_description = f.read()
+
+setup(
+    name='percy-playwright',
+    description='Python client for visual testing with Percy',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    version=percy.__version__,
+    license='MIT',
+    author='Perceptual Inc.',
+    author_email='team@percy.io',
+    url='https://github.com/percy/percy-playwright-python',
+    keywords='percy visual testing',
+    packages=['percy'],
+    include_package_data=True,
+    install_requires=[
+        'playwright>=1.28.0',
+        'requests==2.*'
+    ],
+    python_requires='>=3.6',
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Natural Language :: English',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+    ],
+    test_suite='tests',
+    tests_require=['playwright', 'httpretty'],
+    zip_safe=False
+)

percy_playwright-1.0.0/tests/test_cache.py

@@ -0,0 +1,63 @@
+# . # pylint: disable=[arguments-differ, protected-access]
+import time
+import unittest
+from unittest.mock import patch
+from percy.cache import Cache
+
+
+class TestCache(unittest.TestCase):
+    def setUp(self) -> None:
+        self.cache = Cache
+        self.session_id = "session_id_123"
+        self.session_details = {
+            "browser": "chrome",
+            "platform": "windows",
+            "browserVersion": "115.0.1",
+            "hashed_id": "abcdef",
+        }
+
+        self.cache.set_cache(
+            self.session_id, Cache.session_details, self.session_details
+        )
+        self.cache.set_cache(self.session_id, "key-1", "some-value")
+
+    def test_set_cache(self):
+        with self.assertRaises(Exception) as e:
+            self.cache.set_cache(123, 123, 123)
+        self.assertEqual(str(e.exception), "Argument session_id should be string")
+
+        with self.assertRaises(Exception) as e:
+            self.cache.set_cache(self.session_id, 123, 123)
+        self.assertEqual(str(e.exception), "Argument property should be string")
+
+        self.assertIn(self.session_id, self.cache.CACHE)
+        self.assertDictEqual(
+            self.cache.CACHE[self.session_id][Cache.session_details],
+            self.session_details,
+        )
+
+    def test_get_cache_invalid_args(self):
+        with self.assertRaises(Exception) as e:
+            self.cache.get_cache(123, 123)
+        self.assertEqual(str(e.exception), "Argument session_id should be string")
+
+        with self.assertRaises(Exception) as e:
+            self.cache.get_cache(self.session_id, 123)
+        self.assertEqual(str(e.exception), "Argument property should be string")
+
+    @patch.object(Cache, "cleanup_cache")
+    def test_get_cache_success(self, mock_cleanup_cache):
+        session_details = self.cache.get_cache(self.session_id, Cache.session_details)
+        self.assertDictEqual(session_details, self.session_details)
+        mock_cleanup_cache.assert_called()
+
+    @patch("percy.cache.Cache.CACHE_TIMEOUT", 1)
+    def test_cleanup_cache(self):
+        cache_timeout = self.cache.CACHE_TIMEOUT
+        time.sleep(cache_timeout + 1)
+        self.assertIn(self.session_id, self.cache.CACHE)
+        self.assertIn("key-1", self.cache.CACHE[self.session_id])
+        self.cache.cleanup_cache()
+        self.assertIn(self.session_id, self.cache.CACHE)
+        self.assertIn("session_details", self.cache.CACHE[self.session_id])
+        self.assertNotIn("key-1", self.cache.CACHE[self.session_id])

percy_playwright-1.0.0/tests/test_page_metadata.py

@@ -0,0 +1,51 @@
+# pylint: disable=[abstract-class-instantiated, arguments-differ, protected-access]
+import json
+import unittest
+from unittest.mock import MagicMock, patch
+from percy.cache import Cache
+from percy.page_metadata import PageMetaData
+
+
+class TestPageMetaData(unittest.TestCase):
+    @patch("percy.cache.Cache.get_cache")
+    @patch("percy.cache.Cache.set_cache")
+    def test_page_metadata(self, mock_set_cache, mock_get_cache):
+        # Mock the page and its properties
+        page = MagicMock()
+        page._impl_obj._guid = "page-guid"
+        page.main_frame._impl_obj._guid = "frame-guid"
+        page.context.browser._impl_obj._guid = "browser-guid"
+        page.evaluate.return_value = json.dumps({"hashed_id": "session-id"})
+
+        # Set up the mocks
+        mock_get_cache.return_value = None
+
+        # Create an instance of PageMetaData
+        page_metadata = PageMetaData(page)
+
+        # Test framework property
+        self.assertEqual(page_metadata.framework, "playwright")
+
+        # Test page_guid property
+        self.assertEqual(page_metadata.page_guid, "page-guid")
+
+        # Test frame_guid property
+        self.assertEqual(page_metadata.frame_guid, "frame-guid")
+
+        # Test browser_guid property
+        self.assertEqual(page_metadata.browser_guid, "browser-guid")
+
+        # Test session_details property when cache is empty
+        self.assertEqual(page_metadata.session_details, {"hashed_id": "session-id"})
+        mock_set_cache.assert_called_once_with(
+            "browser-guid", Cache.session_details, {"hashed_id": "session-id"}
+        )
+
+        # Test session_details property when cache is not empty
+        mock_get_cache.return_value = {"hashed_id": "cached-session-id"}
+        self.assertEqual(
+            page_metadata.session_details, {"hashed_id": "cached-session-id"}
+        )
+
+        # Test automate_session_id property
+        self.assertEqual(page_metadata.automate_session_id, "cached-session-id")

percy_playwright-1.0.0/tests/test_screenshot.py

@@ -0,0 +1,372 @@
+# pylint: disable=[abstract-class-instantiated, arguments-differ, protected-access]
+import json
+import unittest
+import platform
+from threading import Thread
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from unittest.mock import patch, MagicMock
+import httpretty
+
+from playwright.sync_api import sync_playwright
+from playwright._repo_version import version as PLAYWRIGHT_VERSION
+from percy.version import __version__ as SDK_VERSION
+from percy.screenshot import (
+    is_percy_enabled,
+    fetch_percy_dom,
+    percy_snapshot,
+    percy_automate_screenshot,
+)
+import percy.screenshot as local
+
+LABEL = local.LABEL
+
+
+# mock a simple webpage to snapshot
+class MockServerRequestHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.end_headers()
+        self.wfile.write(("Snapshot Me").encode("utf-8"))
+
+    def log_message(self, format, *args):
+        return
+
+
+# daemon threads automatically shut down when the main process exits
+mock_server = HTTPServer(("localhost", 8000), MockServerRequestHandler)
+mock_server_thread = Thread(target=mock_server.serve_forever)
+mock_server_thread.daemon = True
+mock_server_thread.start()
+
+# initializing mock data
+data_object = {"sync": "true", "diff": 0}
+
+
+# mock helpers
+def mock_healthcheck(fail=False, fail_how="error", session_type=None):
+    health_body = {"success": True}
+    health_headers = {"X-Percy-Core-Version": "1.0.0"}
+    health_status = 200
+
+    if fail and fail_how == "error":
+        health_body = {"success": False, "error": "test"}
+        health_status = 500
+    elif fail and fail_how == "wrong-version":
+        health_headers = {"X-Percy-Core-Version": "2.0.0"}
+    elif fail and fail_how == "no-version":
+        health_headers = {}
+
+    if session_type:
+        health_body["type"] = session_type
+
+    health_body = json.dumps(health_body)
+    httpretty.register_uri(
+        httpretty.GET,
+        "http://localhost:5338/percy/healthcheck",
+        body=health_body,
+        adding_headers=health_headers,
+        status=health_status,
+    )
+    httpretty.register_uri(
+        httpretty.GET,
+        "http://localhost:5338/percy/dom.js",
+        body="window.PercyDOM = { serialize: () => document.documentElement.outerHTML };",
+        status=200,
+    )
+
+
+def mock_snapshot(fail=False, data=False):
+    httpretty.register_uri(
+        httpretty.POST,
+        "http://localhost:5338/percy/snapshot",
+        body=json.dumps(
+            {
+                "success": "false" if fail else "true",
+                "error": "test" if fail else None,
+                "data": data_object if data else None,
+            }
+        ),
+        status=(500 if fail else 200),
+    )
+
+
+class TestPercySnapshot(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.p = sync_playwright().start()
+        # Launch the browser
+        cls.browser = cls.p.chromium.launch(
+            headless=True
+        )  # Set headless=True if you don't want to see the browser
+        context = cls.browser.new_context()
+        cls.page = context.new_page()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.browser.close()
+        cls.p.stop()
+
+    def setUp(self):
+        # clear the cached value for testing
+        local.is_percy_enabled.cache_clear()
+        local.fetch_percy_dom.cache_clear()
+        self.page.goto("http://localhost:8000")
+        httpretty.enable()
+
+    def tearDown(self):
+        httpretty.disable()
+        httpretty.reset()
+
+    def test_throws_error_when_a_page_is_not_provided(self):
+        with self.assertRaises(Exception):
+            percy_snapshot()
+
+    def test_throws_error_when_a_name_is_not_provided(self):
+        with self.assertRaises(Exception):
+            percy_snapshot(self.page)
+
+    def test_disables_snapshots_when_the_healthcheck_fails(self):
+        mock_healthcheck(fail=True)
+
+        with patch("builtins.print") as mock_print:
+            percy_snapshot(self.page, "Snapshot 1")
+            percy_snapshot(self.page, "Snapshot 2")
+
+            mock_print.assert_called_with(
+                f"{LABEL} Percy is not running, disabling snapshots"
+            )
+
+        self.assertEqual(httpretty.last_request().path, "/percy/healthcheck")
+
+    def test_disables_snapshots_when_the_healthcheck_version_is_wrong(self):
+        mock_healthcheck(fail=True, fail_how="wrong-version")
+
+        with patch("builtins.print") as mock_print:
+            percy_snapshot(self.page, "Snapshot 1")
+            percy_snapshot(self.page, "Snapshot 2")
+
+            mock_print.assert_called_with(
+                f"{LABEL} Unsupported Percy CLI version, 2.0.0"
+            )
+
+        self.assertEqual(httpretty.last_request().path, "/percy/healthcheck")
+
+    def test_disables_snapshots_when_the_healthcheck_version_is_missing(self):
+        mock_healthcheck(fail=True, fail_how="no-version")
+
+        with patch("builtins.print") as mock_print:
+            percy_snapshot(self.page, "Snapshot 1")
+            percy_snapshot(self.page, "Snapshot 2")
+
+            mock_print.assert_called_with(
+                f"{LABEL} You may be using @percy/agent which is no longer supported by this SDK. "
+                "Please uninstall @percy/agent and install @percy/cli instead. "
+                "https://www.browserstack.com/docs/percy/migration/migrate-to-cli"
+            )
+
+        self.assertEqual(httpretty.last_request().path, "/percy/healthcheck")
+
+    def test_posts_snapshots_to_the_local_percy_server(self):
+        mock_healthcheck()
+        mock_snapshot()
+
+        percy_snapshot(self.page, "Snapshot 1")
+        response = percy_snapshot(self.page, "Snapshot 2", enable_javascript=True)
+
+        self.assertEqual(httpretty.last_request().path, "/percy/snapshot")
+
+        s1 = httpretty.latest_requests()[2].parsed_body
+        self.assertEqual(s1["name"], "Snapshot 1")
+        self.assertEqual(s1["url"], "http://localhost:8000/")
+        self.assertEqual(
+            s1["dom_snapshot"], "<html><head></head><body>Snapshot Me</body></html>"
+        )
+        self.assertRegex(s1["client_info"], r"percy-playwright-python/\d+")
+        self.assertRegex(s1["environment_info"][0], r"playwright/\d+")
+        self.assertRegex(s1["environment_info"][1], r"python/\d+")
+
+        s2 = httpretty.latest_requests()[3].parsed_body
+        self.assertEqual(s2["name"], "Snapshot 2")
+        self.assertEqual(s2["enable_javascript"], True)
+        self.assertEqual(response, None)
+
+    def test_posts_snapshots_to_the_local_percy_server_for_sync(self):
+        mock_healthcheck()
+        mock_snapshot(False, True)
+
+        percy_snapshot(self.page, "Snapshot 1")
+        response = percy_snapshot(
+            self.page, "Snapshot 2", enable_javascript=True, sync=True
+        )
+
+        self.assertEqual(httpretty.last_request().path, "/percy/snapshot")
+
+        s1 = httpretty.latest_requests()[2].parsed_body
+        self.assertEqual(s1["name"], "Snapshot 1")
+        self.assertEqual(s1["url"], "http://localhost:8000/")
+        self.assertEqual(
+            s1["dom_snapshot"], "<html><head></head><body>Snapshot Me</body></html>"
+        )
+        self.assertRegex(s1["client_info"], r"percy-playwright-python/\d+")
+        self.assertRegex(s1["environment_info"][0], r"playwright/\d+")
+        self.assertRegex(s1["environment_info"][1], r"python/\d+")
+
+        s2 = httpretty.latest_requests()[3].parsed_body
+        self.assertEqual(s2["name"], "Snapshot 2")
+        self.assertEqual(s2["enable_javascript"], True)
+        self.assertEqual(s2["sync"], True)
+        self.assertEqual(response, data_object)
+
+        mock_healthcheck()
+        mock_snapshot()
+
+        percy_snapshot(self.page, "Snapshot")
+
+        self.assertEqual(httpretty.last_request().path, "/percy/snapshot")
+
+        s1 = httpretty.latest_requests()[-1].parsed_body
+        self.assertEqual(s1["name"], "Snapshot")
+        self.assertEqual(s1["url"], "http://localhost:8000/")
+        self.assertEqual(
+            s1["dom_snapshot"], "<html><head></head><body>Snapshot Me</body></html>"
+        )
+
+    def test_handles_snapshot_errors(self):
+        mock_healthcheck(session_type="web")
+        mock_snapshot(fail=True)
+
+        with patch("builtins.print") as mock_print:
+            percy_snapshot(self.page, "Snapshot 1")
+
+            mock_print.assert_any_call(
+                f'{LABEL} Could not take DOM snapshot "Snapshot 1"'
+            )
+
+    def test_raise_error_poa_token_with_snapshot(self):
+        mock_healthcheck(session_type="automate")
+
+        with self.assertRaises(Exception) as context:
+            percy_snapshot(self.page, "Snapshot 1")
+
+        self.assertEqual(
+            "Invalid function call - "
+            "percy_snapshot(). Please use percy_screenshot() "
+            "function while using Percy with Automate."
+            " For more information on usage of PercyScreenshot, refer https://www.browserstack.com/"
+            "docs/percy/integrate/functional-and-visual",
+            str(context.exception),
+        )
+
+
+class TestPercyFunctions(unittest.TestCase):
+    @patch("requests.get")
+    def test_is_percy_enabled(self, mock_get):
+        # Mock successful health check
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {"success": True, "type": "web"}
+        mock_get.return_value.headers = {"x-percy-core-version": "1.0.0"}
+
+        self.assertEqual(is_percy_enabled(), "web")
+
+        # Clear the cache to test the unsuccessful scenario
+        is_percy_enabled.cache_clear()
+
+        # Mock unsuccessful health check
+        mock_get.return_value.json.return_value = {"success": False, "error": "error"}
+        self.assertFalse(is_percy_enabled())
+
+    @patch("requests.get")
+    def test_fetch_percy_dom(self, mock_get):
+        # Mock successful fetch of dom.js
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.text = "some_js_code"
+
+        self.assertEqual(fetch_percy_dom(), "some_js_code")
+
+    @patch("requests.post")
+    @patch("percy.screenshot.fetch_percy_dom")
+    @patch("percy.screenshot.is_percy_enabled")
+    def test_percy_snapshot(
+        self, mock_is_percy_enabled, mock_fetch_percy_dom, mock_post
+    ):
+        # Mock Percy enabled
+        mock_is_percy_enabled.return_value = "web"
+        mock_fetch_percy_dom.return_value = "some_js_code"
+        page = MagicMock()
+        page.evaluate.side_effect = [
+            "dom_snapshot",
+            json.dumps({"hashed_id": "session-id"}),
+        ]
+        page.url = "http://example.com"
+        mock_post.return_value.status_code = 200
+        mock_post.return_value.json.return_value = {
+            "success": True,
+            "data": "snapshot_data",
+        }
+
+        # Call the function
+        result = percy_snapshot(page, "snapshot_name")
+
+        # Check the results
+        self.assertEqual(result, "snapshot_data")
+        mock_post.assert_called_once()
+
+    @patch("requests.post")
+    @patch("percy.screenshot.is_percy_enabled")
+    def test_percy_automate_screenshot(self, mock_is_percy_enabled, mock_post):
+        # Mock Percy enabled for automate
+        is_percy_enabled.cache_clear()
+        mock_is_percy_enabled.return_value = "automate"
+        page = MagicMock()
+
+        page._impl_obj._guid = "page@abc"
+        page.main_frame._impl_obj._guid = "frame@abc"
+        page.context.browser._impl_obj._guid = "browser@abc"
+        page.evaluate.return_value = '{"hashed_id": "session_id"}'
+
+        # Mock the response for the POST request
+        mock_post.return_value.status_code = 200
+        mock_post.return_value.json.return_value = {
+            "success": True,
+            "data": "screenshot_data",
+        }
+
+        # Call the function
+        result = percy_automate_screenshot(page, "screenshot_name")
+
+        # Assertions
+        self.assertEqual(result, "screenshot_data")
+        mock_post.assert_called_once_with(
+            "http://localhost:5338/percy/automateScreenshot",
+            json={
+                "client_info": f"percy-playwright-python/{SDK_VERSION}",
+                "environment_info": [
+                    f"playwright/{PLAYWRIGHT_VERSION}",
+                    f"python/{platform.python_version()}",
+                ],
+                "sessionId": "session_id",
+                "pageGuid": "page@abc",
+                "frameGuid": "frame@abc",
+                "framework": "playwright",
+                "snapshotName": "screenshot_name",
+                "options": {},
+            },
+            timeout=600,
+        )
+
+    @patch("percy.screenshot.is_percy_enabled")
+    def test_percy_automate_screenshot_invalid_call(self, mock_is_percy_enabled):
+        # Mock Percy enabled for web
+        mock_is_percy_enabled.return_value = "web"
+        page = MagicMock()
+
+        # Call the function and expect an exception
+        with self.assertRaises(Exception) as context:
+            percy_automate_screenshot(page, "screenshot_name")
+
+        self.assertTrue("Invalid function call" in str(context.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()