easy-playwright 0.0.4__tar.gz

easy_playwright-0.0.4/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2024, Quentin REMPLAKOWSKI
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

easy_playwright-0.0.4/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: easy_playwright
+Version: 0.0.4
+Summary: Playwright runner with persistent Chromium and one-line CLI.
+Author-email: Quentin REMPLAKOWSKI <q.rempla@gmail.com>
+Project-URL: Homepage, https://github.com/qremplak/easy_playwright
+Project-URL: Issues, https://github.com/qremplak/easy_playwright/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: playwright>=1.53.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# easy_playwright
+
+An ultra-simple Playwright runner that executes Python snippets while reusing a persistent Chromium session across calls.
+
+# Why ?
+
+Traditionnal playwright MCP allow agent to call a subset of playwright functions one by one.
+An alternative is to allow agent to execute arbitrary python code using playwright package to freely access full API, but it general the browser is closed after each code execution.
+
+easy_playwright allows :
+- Mandatory Chromium/deps installation during pip build/install (fails fast on error)
+- Auto chromium startup and persistence
+- Single tool call for agent to execute any python playwright routine
+- Reusing previous session accross executions
+- Easy traces and screenshots captures and storage in local folder to allow human and agent monitoring
+- Auto-embedding of development workflow instructions to improve agent coding autonomy
+
+## Installation
+
+easy_playwright is designed to allow easy and light setup of playwright and chromium in same host (local dev machine or dev container)
+
+> pip install -v --no-binary easy-playwright easy-playwright
+(--no-binary is needed to force auto chromium installation in expected folder)
+
+Then, add following instructions in your agent context :
+```
+Always use the ezpw tool to check your work. Run the following command, read the output carefully, and strictly follow the instructions provided.
+> ezpw -h
+```
+
+## Persistent Chromium
+
+The browser is started automatically if not already running. The persistent profile is stored in:
+
+```
+.playwright/runtime/chromium-profile/
+```
+
+This keeps state between calls (cookies, login session, etc.).
+
+Tip: `playwright` reuses the first open tab if possible, otherwise it creates a new one.
+
+## Environment variables
+
+- `EASY_PLAYWRIGHT_DIR`: base folder (default `.playwright`).
+- `EASY_PLAYWRIGHT_CDP_PORT`: CDP port (default `9222`).
+- `EASY_PLAYWRIGHT_START_URL`: URL opened on startup (default `about:blank`).
+- `EASY_PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD`: if `1`, do not download Chromium during `pip install`.

easy_playwright-0.0.4/README.md

@@ -0,0 +1,48 @@
+# easy_playwright
+
+An ultra-simple Playwright runner that executes Python snippets while reusing a persistent Chromium session across calls.
+
+# Why ?
+
+Traditionnal playwright MCP allow agent to call a subset of playwright functions one by one.
+An alternative is to allow agent to execute arbitrary python code using playwright package to freely access full API, but it general the browser is closed after each code execution.
+
+easy_playwright allows :
+- Mandatory Chromium/deps installation during pip build/install (fails fast on error)
+- Auto chromium startup and persistence
+- Single tool call for agent to execute any python playwright routine
+- Reusing previous session accross executions
+- Easy traces and screenshots captures and storage in local folder to allow human and agent monitoring
+- Auto-embedding of development workflow instructions to improve agent coding autonomy
+
+## Installation
+
+easy_playwright is designed to allow easy and light setup of playwright and chromium in same host (local dev machine or dev container)
+
+> pip install -v --no-binary easy-playwright easy-playwright
+(--no-binary is needed to force auto chromium installation in expected folder)
+
+Then, add following instructions in your agent context :
+```
+Always use the ezpw tool to check your work. Run the following command, read the output carefully, and strictly follow the instructions provided.
+> ezpw -h
+```
+
+## Persistent Chromium
+
+The browser is started automatically if not already running. The persistent profile is stored in:
+
+```
+.playwright/runtime/chromium-profile/
+```
+
+This keeps state between calls (cookies, login session, etc.).
+
+Tip: `playwright` reuses the first open tab if possible, otherwise it creates a new one.
+
+## Environment variables
+
+- `EASY_PLAYWRIGHT_DIR`: base folder (default `.playwright`).
+- `EASY_PLAYWRIGHT_CDP_PORT`: CDP port (default `9222`).
+- `EASY_PLAYWRIGHT_START_URL`: URL opened on startup (default `about:blank`).
+- `EASY_PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD`: if `1`, do not download Chromium during `pip install`.

easy_playwright-0.0.4/easy_playwright/__init__.py

@@ -0,0 +1,6 @@
+"""Minimal Playwright runner with persistent Chromium."""
+
+from .runner import run_snippet, ensure_chromium_running
+
+__all__ = ["run_snippet", "ensure_chromium_running"]
+__version__ = "0.4.0"

easy_playwright-0.0.4/easy_playwright/cli.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .config import DEFAULT_HEADLESS, DEFAULT_START_URL, DEFAULT_WINDOW_SIZE
+from .runner import RunOptions, run_snippet
+
+
+def _read_code_from_stdin() -> str:
+    if sys.stdin is None or sys.stdin.isatty():
+        return ""
+    return sys.stdin.read()
+
+
+def _parse_window_size(value: str) -> tuple[int, int]:
+    try:
+        width_str, height_str = value.lower().split("x", 1)
+        width = int(width_str)
+        height = int(height_str)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError(
+            "Invalid format for --window-size. Use WIDTHxHEIGHT, for example 1920x1080."
+        ) from exc
+
+    if width <= 0 or height <= 0:
+        raise argparse.ArgumentTypeError("Window size must be positive integers.")
+    return (width, height)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="ezpw",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="""All-in-one tool to easily check web app behavior using playwright.
+        
+ezpw allows executing a playwright Python snippet within a persistent Chromium session.
+
+Example 1 : Navigate + Screenshot
+ezpw "
+# NOW, EXPORT_FOLDER, playwright, page, context and browser are directly available in ezpw scope
+#print(page)
+#print(context)
+
+# By default, you are on the page that was left open during the previous call, but you can change it.
+# page.goto('http://127.0.0.1:8080', wait_until='networkidle')
+
+page.fill('#name', 'Agent_IA_001')
+page.click('.start-btn')
+page.screenshot(path=EXPORT_FOLDER/f'screenshots/{NOW}_after_click.png', full_page=True)
+"
+
+# Example 2 : Traces capture
+ezpw "
+context.tracing.start(screenshots=True, snapshots=True, sources=True)
+page.goto('http://127.0.0.1:8080/page_to_test', wait_until='networkidle')
+context.tracing.stop(path=EXPORT_FOLDER/f'traces/{NOW}_page_to_test.zip')
+"
+
+You have access to entire playwright API.
+
+**Iterative Test & Adjust Development Workflow**
+
+Systematically:
+
+- Produce the code to meet the requested requirement.  
+- Use Playwright to test the application:  
+  - Navigate and interact within the application to ensure everything works as expected.  
+  - Capture traces and take screenshots to visually verify that the application's appearance matches the expectations.  
+- Review the traces and screenshots you have generated to analyze them. Examples:  
+  - Reading an image via `functions.view_image` ([https://developers.openai.com/cookbook/examples/gpt-5/codex\_prompting\_guide/](https://developers.openai.com/cookbook/examples/gpt-5/codex_prompting_guide/))  
+  - Reading logs via `cat` / `sed`.  
+- Adjust the code until everything functions as expected and the UI is visually clean and compliant with the requirements.
+
+Any capture or trace must be saved and organized in the dedicated folder, as showed in examples below.
+""",
+    )
+    parser.add_argument("code", nargs="?", help="Python code to execute.")
+    parser.add_argument("--port", type=int, default=None, help="CDP port (default: 9222).")
+    parser.add_argument(
+        "--headless",
+        action=argparse.BooleanOptionalAction,
+        default=DEFAULT_HEADLESS,
+        help="Run Chromium in headless mode (default: true).",
+    )
+    parser.add_argument(
+        "--start-url",
+        default=None,
+        help="URL to open when Chromium starts (default: about:blank).",
+    )
+    parser.add_argument(
+        "--window-size",
+        type=_parse_window_size,
+        default=DEFAULT_WINDOW_SIZE,
+        help="Chromium window size in pixels as WIDTHxHEIGHT (default: 1920x1080).",
+    )
+
+    args = parser.parse_args()
+    code = args.code or _read_code_from_stdin()
+    if not code or not code.strip():
+        parser.error("Provide code as an argument or via stdin.")
+
+    options = RunOptions(
+        code=code,
+        port=args.port,
+        headless=args.headless,
+        start_url=args.start_url or DEFAULT_START_URL,
+        window_size=args.window_size,
+    )
+    result = run_snippet(options)
+    print(f"OK | port={result['port']} | export_folder={result['export_folder']}")
+
+
+if __name__ == "__main__":
+    main()

easy_playwright-0.0.4/easy_playwright/config.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+DEFAULT_BASE_DIRNAME = ".playwright"
+DEFAULT_CDP_PORT = 9222
+DEFAULT_START_URL = "about:blank"
+DEFAULT_HEADLESS = True
+DEFAULT_WINDOW_SIZE = (1920, 1080)
+DEFAULT_PLAYWRIGHT_BROWSERS_PATH = "/ms-playwright"
+
+
+def get_project_dir() -> Path:
+    env = os.environ.get("EASY_PLAYWRIGHT_PROJECT_DIR")
+    if env:
+        return Path(env).expanduser().resolve()
+    return Path.cwd().resolve()
+
+
+def get_base_dir(project_dir: Path) -> Path:
+    env = os.environ.get("EASY_PLAYWRIGHT_DIR")
+    base = Path(env).expanduser().resolve() if env else (project_dir / DEFAULT_BASE_DIRNAME)
+    base.mkdir(parents=True, exist_ok=True)
+    return base
+
+
+def get_playwright_browsers_path() -> str:
+    return DEFAULT_PLAYWRIGHT_BROWSERS_PATH
+
+
+def get_runtime_dir(base_dir: Path) -> Path:
+    runtime = base_dir / "runtime"
+    runtime.mkdir(parents=True, exist_ok=True)
+    return runtime
+
+
+def get_profile_dir(runtime_dir: Path) -> Path:
+    profile = runtime_dir / "chromium-profile"
+    profile.mkdir(parents=True, exist_ok=True)
+    return profile
+
+
+def get_export_dir(base_dir: Path) -> Path:
+    exports = base_dir / "exports"
+    exports.mkdir(parents=True, exist_ok=True)
+    return exports
+
+
+def get_log_path(runtime_dir: Path) -> Path:
+    return runtime_dir / "chromium.log"

easy_playwright-0.0.4/easy_playwright/runner.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import json
+import os
+import socket
+from collections import deque
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from urllib.error import URLError
+from urllib.request import urlopen
+
+from playwright.sync_api import sync_playwright
+
+from .config import (
+    DEFAULT_CDP_PORT,
+    DEFAULT_HEADLESS,
+    DEFAULT_START_URL,
+    DEFAULT_WINDOW_SIZE,
+    get_base_dir,
+    get_export_dir,
+    get_log_path,
+    get_profile_dir,
+    get_project_dir,
+    get_playwright_browsers_path,
+    get_runtime_dir,
+)
+
+
+@dataclass
+class RunOptions:
+    code: str
+    port: Optional[int] = None
+    headless: bool = DEFAULT_HEADLESS
+    start_url: str = DEFAULT_START_URL
+    window_size: Optional[tuple[int, int]] = DEFAULT_WINDOW_SIZE
+
+
+def _fetch_cdp_version(port: int, timeout: float = 0.5) -> Optional[dict]:
+    url = f"http://127.0.0.1:{port}/json/version"
+    try:
+        with urlopen(url, timeout=timeout) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        if "webSocketDebuggerUrl" in data:
+            return data
+        return None
+    except URLError:
+        return None
+
+
+def _is_cdp_ready(port: int) -> bool:
+    return _fetch_cdp_version(port) is not None
+
+
+def _is_port_in_use(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(0.2)
+        return sock.connect_ex(("127.0.0.1", port)) == 0
+
+
+def _tail_log(path: Path, max_lines: int = 50) -> str:
+    if not path.exists():
+        return ""
+    try:
+        with path.open("r", encoding="utf-8", errors="replace") as handle:
+            lines = deque(handle, maxlen=max_lines)
+        return "".join(lines)
+    except Exception:
+        return ""
+
+
+def _wait_for_cdp(port: int, timeout: float, proc: Optional[subprocess.Popen] = None) -> None:
+    start = time.time()
+    while time.time() - start < timeout:
+        if _is_cdp_ready(port):
+            return
+        if proc is not None and proc.poll() is not None:
+            raise RuntimeError(f"Chromium process exited early (code {proc.returncode}).")
+        time.sleep(0.25)
+    raise RuntimeError(
+        f"Chromium ne repond pas sur le port {port}. "
+        "Verifie que le port est libre ou change-le via --port."
+    )
+
+
+def _apply_window_size(page, window_size: tuple[int, int]) -> None:
+    width, height = window_size
+    # Try to resize the real browser window (headful mode), then fall back to viewport.
+    try:
+        session = page.context.new_cdp_session(page)
+        window_info = session.send("Browser.getWindowForTarget")
+        session.send(
+            "Browser.setWindowBounds",
+            {
+                "windowId": window_info["windowId"],
+                "bounds": {"width": width, "height": height},
+            },
+        )
+        return
+    except Exception:
+        pass
+
+    try:
+        page.set_viewport_size({"width": width, "height": height})
+    except Exception:
+        pass
+
+
+def _configure_playwright_browsers_path() -> None:
+    path = get_playwright_browsers_path()
+    os.environ["PLAYWRIGHT_BROWSERS_PATH"] = path
+    try:
+        Path(path).mkdir(parents=True, exist_ok=True)
+    except Exception:
+        # If path creation fails, Playwright will raise a clearer install/runtime error.
+        pass
+
+
+def _ensure_chromium_installed() -> Path:
+    _configure_playwright_browsers_path()
+    browsers_path = os.environ.get("PLAYWRIGHT_BROWSERS_PATH", "")
+    with sync_playwright() as p:
+        exe = Path(p.chromium.executable_path)
+    if exe.exists():
+        return exe
+
+    raise RuntimeError(
+        "Chromium is not installed, you have 2 choices :\n"
+        "- Force chromium installation during pip install :\n" \
+        "> pip install --no-binary easy-playwright easy-playwright\n"
+        "- Install chromium manually :\n"
+        f"> PLAYWRIGHT_BROWSERS_PATH={browsers_path} {sys.executable} -m playwright install chromium "
+    )
+
+
+def ensure_chromium_running(
+    port: Optional[int] = None,
+    headless: Optional[bool] = None,
+    start_url: Optional[str] = None,
+    window_size: Optional[tuple[int, int]] = None,
+    base_dir: Optional[Path] = None,
+) -> None:
+    _configure_playwright_browsers_path()
+    project_dir = get_project_dir()
+    base = base_dir or get_base_dir(project_dir)
+    port = port or int(os.environ.get("EASY_PLAYWRIGHT_CDP_PORT", DEFAULT_CDP_PORT))
+    headless = DEFAULT_HEADLESS if headless is None else headless
+    start_url = start_url or os.environ.get("EASY_PLAYWRIGHT_START_URL", DEFAULT_START_URL)
+
+    if _is_cdp_ready(port):
+        return
+    if _is_port_in_use(port):
+        raise RuntimeError(
+            f"Le port {port} est deja utilise mais ne repond pas en CDP. "
+            "Change le port ou arrete le processus qui l'utilise."
+        )
+
+    exe = _ensure_chromium_installed()
+    runtime_dir = get_runtime_dir(base)
+    profile_dir = get_profile_dir(runtime_dir)
+    log_path = get_log_path(runtime_dir)
+
+    args = [
+        str(exe),
+        f"--remote-debugging-port={port}",
+        "--remote-debugging-address=127.0.0.1",
+        "--remote-allow-origins=*",
+        f"--user-data-dir={profile_dir}",
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-gpu",
+    ]
+    if headless:
+        args.append("--headless")
+    width, height = window_size or DEFAULT_WINDOW_SIZE
+    args.append(f"--window-size={width},{height}")
+    args.append(start_url)
+
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    log_file = open(log_path, "a", encoding="utf-8")
+    proc = subprocess.Popen(
+        args,
+        stdout=log_file,
+        stderr=log_file,
+        start_new_session=True,
+    )
+    log_file.close()
+
+    timeout_env = os.environ.get("EASY_PLAYWRIGHT_CDP_TIMEOUT", "15")
+    try:
+        timeout = float(timeout_env)
+    except ValueError:
+        timeout = 15.0
+
+    try:
+        _wait_for_cdp(port, timeout=timeout, proc=proc)
+    except RuntimeError as exc:
+        log_tail = _tail_log(log_path)
+        details = f"{exc} (see {log_path})"
+        if log_tail:
+            details = f"{details}\n--- chromium.log (tail) ---\n{log_tail}"
+        raise RuntimeError(details) from exc
+
+
+def run_snippet(options: RunOptions) -> dict:
+    project_dir = get_project_dir()
+    base_dir = get_base_dir(project_dir)
+    export_dir = get_export_dir(base_dir)
+    port = options.port or int(os.environ.get("EASY_PLAYWRIGHT_CDP_PORT", DEFAULT_CDP_PORT))
+
+    ensure_chromium_running(
+        port=port,
+        headless=options.headless,
+        start_url=options.start_url,
+        window_size=options.window_size,
+        base_dir=base_dir,
+    )
+
+    with sync_playwright() as p:
+        browser = p.chromium.connect_over_cdp(f"http://127.0.0.1:{port}")
+        context = browser.contexts[0] if browser.contexts else browser.new_context()
+        page = context.pages[0] if context.pages else context.new_page()
+        _apply_window_size(page, options.window_size or DEFAULT_WINDOW_SIZE)
+
+        exec_error: Optional[BaseException] = None
+        try:
+            now_stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+            scope = {
+                "page": page,
+                "context": context,
+                "browser": browser,
+                "playwright": p,
+                "NOW": now_stamp,
+                "EXPORT_FOLDER": export_dir,
+            }
+            compiled = compile(options.code, "<easy_playwright>", "exec")
+            exec(compiled, scope, scope)
+        except BaseException as exc:
+            exec_error = exc
+        finally:
+            browser.close()
+
+        if exec_error:
+            raise exec_error
+
+    return {
+        "now": now_stamp,
+        "export_folder": str(export_dir),
+        "port": port,
+    }

easy_playwright-0.0.4/easy_playwright.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: easy_playwright
+Version: 0.0.4
+Summary: Playwright runner with persistent Chromium and one-line CLI.
+Author-email: Quentin REMPLAKOWSKI <q.rempla@gmail.com>
+Project-URL: Homepage, https://github.com/qremplak/easy_playwright
+Project-URL: Issues, https://github.com/qremplak/easy_playwright/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: playwright>=1.53.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# easy_playwright
+
+An ultra-simple Playwright runner that executes Python snippets while reusing a persistent Chromium session across calls.
+
+# Why ?
+
+Traditionnal playwright MCP allow agent to call a subset of playwright functions one by one.
+An alternative is to allow agent to execute arbitrary python code using playwright package to freely access full API, but it general the browser is closed after each code execution.
+
+easy_playwright allows :
+- Mandatory Chromium/deps installation during pip build/install (fails fast on error)
+- Auto chromium startup and persistence
+- Single tool call for agent to execute any python playwright routine
+- Reusing previous session accross executions
+- Easy traces and screenshots captures and storage in local folder to allow human and agent monitoring
+- Auto-embedding of development workflow instructions to improve agent coding autonomy
+
+## Installation
+
+easy_playwright is designed to allow easy and light setup of playwright and chromium in same host (local dev machine or dev container)
+
+> pip install -v --no-binary easy-playwright easy-playwright
+(--no-binary is needed to force auto chromium installation in expected folder)
+
+Then, add following instructions in your agent context :
+```
+Always use the ezpw tool to check your work. Run the following command, read the output carefully, and strictly follow the instructions provided.
+> ezpw -h
+```
+
+## Persistent Chromium
+
+The browser is started automatically if not already running. The persistent profile is stored in:
+
+```
+.playwright/runtime/chromium-profile/
+```
+
+This keeps state between calls (cookies, login session, etc.).
+
+Tip: `playwright` reuses the first open tab if possible, otherwise it creates a new one.
+
+## Environment variables
+
+- `EASY_PLAYWRIGHT_DIR`: base folder (default `.playwright`).
+- `EASY_PLAYWRIGHT_CDP_PORT`: CDP port (default `9222`).
+- `EASY_PLAYWRIGHT_START_URL`: URL opened on startup (default `about:blank`).
+- `EASY_PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD`: if `1`, do not download Chromium during `pip install`.

easy_playwright-0.0.4/easy_playwright.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+easy_playwright/__init__.py
+easy_playwright/cli.py
+easy_playwright/config.py
+easy_playwright/runner.py
+easy_playwright.egg-info/PKG-INFO
+easy_playwright.egg-info/SOURCES.txt
+easy_playwright.egg-info/dependency_links.txt
+easy_playwright.egg-info/entry_points.txt
+easy_playwright.egg-info/requires.txt
+easy_playwright.egg-info/top_level.txt

easy_playwright-0.0.4/easy_playwright.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

easy_playwright-0.0.4/easy_playwright.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ezpw = easy_playwright.cli:main

easy_playwright-0.0.4/easy_playwright.egg-info/requires.txt

@@ -0,0 +1,4 @@
+playwright>=1.53.0
+
+[dev]
+pytest

easy_playwright-0.0.4/easy_playwright.egg-info/top_level.txt

@@ -0,0 +1 @@
+easy_playwright

easy_playwright-0.0.4/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "easy_playwright"
+version = "0.0.4"
+authors = [
+  { name="Quentin REMPLAKOWSKI", email="q.rempla@gmail.com" },
+]
+description = "Playwright runner with persistent Chromium and one-line CLI."
+readme = "README.md"
+
+# playwright requires 3.9
+requires-python = ">=3.9"
+classifiers=[
+    'Development Status :: 5 - Production/Stable',
+    'Intended Audience :: Developers',
+    "Topic :: Scientific/Engineering",
+    'License :: OSI Approved :: BSD License',  
+    'Operating System :: OS Independent',
+    "Programming Language :: Python :: 3",
+    'Programming Language :: Python :: 3.10',
+]
+
+dependencies = [
+  "playwright>=1.53.0"
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest"
+]
+
+[project.scripts]
+ezpw = "easy_playwright.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["easy_playwright", "easy_playwright.*"]
+namespaces = false
+
+[project.urls]
+Homepage = "https://github.com/qremplak/easy_playwright"
+Issues = "https://github.com/qremplak/easy_playwright/issues"
+
+[build-system]
+requires = ["setuptools>=61.0", "playwright"]
+build-backend = "setuptools.build_meta"

easy_playwright-0.0.4/setup.cfg

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

easy_playwright-0.0.4/setup.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+from setuptools import setup
+from setuptools.command.build_py import build_py
+from setuptools.command.develop import develop
+from setuptools.command.install import install
+
+_BROWSER_INSTALL_DONE = False
+
+
+def _get_browsers_path() -> str:
+    return "/ms-playwright"
+
+
+def _install_chromium() -> None:
+    global _BROWSER_INSTALL_DONE
+    if _BROWSER_INSTALL_DONE:
+        return
+    if os.environ.get("EASY_PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD") == "1":
+        print("[easy_playwright] Skipping browser installation (EASY_PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1)")
+        _BROWSER_INSTALL_DONE = True
+        return
+    browsers_path = _get_browsers_path()
+    os.makedirs(browsers_path, exist_ok=True)
+    env = os.environ.copy()
+    env["PLAYWRIGHT_BROWSERS_PATH"] = browsers_path
+    print("[easy_playwright] Installing Chromium during build/install...")
+    print(f"[easy_playwright] PLAYWRIGHT_BROWSERS_PATH={browsers_path}")
+    print(f"[easy_playwright] > {sys.executable} -m playwright install chromium")
+    subprocess.check_call([sys.executable, "-m", "playwright", "install", "chromium"], env=env)
+    print(f"[easy_playwright] > {sys.executable} -m playwright install-deps chromium")
+    subprocess.check_call([sys.executable, "-m", "playwright", "install-deps", "chromium"], env=env)
+    _BROWSER_INSTALL_DONE = True
+
+
+class BuildPyWithPlaywright(build_py):
+    def run(self) -> None:
+        _install_chromium()
+        super().run()
+
+
+class InstallWithPlaywright(install):
+    def run(self) -> None:
+        _install_chromium()
+        super().run()
+
+
+class DevelopWithPlaywright(develop):
+    def run(self) -> None:
+        _install_chromium()
+        super().run()
+
+
+setup(
+    cmdclass={
+        "build_py": BuildPyWithPlaywright,
+        "install": InstallWithPlaywright,
+        "develop": DevelopWithPlaywright,
+    }
+)