rustwright 0.1.0__cp38-abi3-win_amd64.whl

rustwright/__init__.py

@@ -0,0 +1,56 @@
+"""Rust-backed browser automation with a Playwright-shaped Python API."""
+
+from ._compat import disable_playwright_compat, enable_playwright_compat
+from .sync_api import (
+    Browser,
+    BrowserContext,
+    BrowserType,
+    BackendMarker,
+    ConsoleMessage,
+    ElementHandle,
+    Error,
+    Download,
+    FileChooser,
+    Frame,
+    FrameLocator,
+    JSHandle,
+    Locator,
+    Page,
+    Playwright,
+    Response,
+    TargetClosedError,
+    TimeoutError,
+    Video,
+    backend_marker,
+    expect,
+    sync_playwright,
+)
+from .async_api import async_playwright
+
+__all__ = [
+    "Browser",
+    "BrowserContext",
+    "BrowserType",
+    "BackendMarker",
+    "ConsoleMessage",
+    "Download",
+    "ElementHandle",
+    "Error",
+    "FileChooser",
+    "Frame",
+    "FrameLocator",
+    "JSHandle",
+    "Locator",
+    "Page",
+    "Playwright",
+    "Response",
+    "TargetClosedError",
+    "TimeoutError",
+    "Video",
+    "backend_marker",
+    "disable_playwright_compat",
+    "enable_playwright_compat",
+    "expect",
+    "async_playwright",
+    "sync_playwright",
+]

rustwright/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(program="rustwright"))

rustwright/_backend.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from importlib import metadata
+from pathlib import Path
+from typing import Optional, TypedDict
+
+from . import _rustwright
+
+
+class BackendMarker(TypedDict):
+    implementation: str
+    package: str
+    version: str
+    api_package: str
+    api_module: str
+    replacement_backend: bool
+    runtime: str
+    runtime_module: str
+    runtime_module_file: Optional[str]
+    transport: str
+    transport_protocol: str
+    cdp_first: bool
+    python_playwright_driver: bool
+    playwright_driver: str
+
+
+def _version() -> str:
+    try:
+        return metadata.version("rustwright")
+    except metadata.PackageNotFoundError:
+        return "0.1.0+local"
+
+
+def backend_marker(api_module: str | None = None) -> BackendMarker:
+    """Return JSON-safe evidence that this API is backed by Rustwright CDP."""
+
+    module_name = api_module or "rustwright"
+    api_package = module_name.split(".", 1)[0]
+    runtime_file = getattr(_rustwright, "__file__", None)
+    return {
+        "implementation": "rustwright",
+        "package": "rustwright",
+        "version": _version(),
+        "api_package": api_package,
+        "api_module": module_name,
+        "replacement_backend": True,
+        "runtime": "rust-pyo3-extension",
+        "runtime_module": _rustwright.__name__,
+        "runtime_module_file": str(Path(runtime_file).resolve()) if runtime_file else None,
+        "transport": "raw-cdp",
+        "transport_protocol": "Chrome DevTools Protocol",
+        "cdp_first": True,
+        "python_playwright_driver": False,
+        "playwright_driver": "none",
+    }
+
+
+__all__ = ["BackendMarker", "backend_marker"]

rustwright/_compat/__init__.py

@@ -0,0 +1,83 @@
+"""Explicit opt-in Playwright/Patchright/Cloakbrowser import compatibility."""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from types import ModuleType
+from typing import Optional
+
+
+_ALIASES = (
+    ("playwright", "rustwright._compat.playwright"),
+    ("playwright.__main__", "rustwright._compat.playwright.__main__"),
+    ("playwright._impl", "rustwright._compat.playwright._impl"),
+    ("playwright._impl._errors", "rustwright._compat.playwright._impl._errors"),
+    ("playwright.async_api", "rustwright._compat.playwright.async_api"),
+    ("playwright.pytest_plugin", "rustwright._compat.playwright.pytest_plugin"),
+    ("playwright.sync_api", "rustwright._compat.playwright.sync_api"),
+    ("patchright", "rustwright._compat.patchright"),
+    ("patchright.__main__", "rustwright._compat.patchright.__main__"),
+    ("patchright._impl", "rustwright._compat.patchright._impl"),
+    ("patchright._impl._errors", "rustwright._compat.patchright._impl._errors"),
+    ("patchright.async_api", "rustwright._compat.patchright.async_api"),
+    ("patchright.pytest_plugin", "rustwright._compat.patchright.pytest_plugin"),
+    ("patchright.sync_api", "rustwright._compat.patchright.sync_api"),
+    ("cloakbrowser", "rustwright._compat.cloakbrowser"),
+    ("pytest_playwright", "rustwright._compat.pytest_playwright"),
+    ("pytest_playwright.pytest_playwright", "rustwright._compat.pytest_playwright.pytest_playwright"),
+)
+
+_PREVIOUS_MODULES: dict[str, Optional[ModuleType]] = {}
+_ENABLED = False
+
+
+def _set_parent_attribute(module_name: str, module: ModuleType) -> None:
+    parent_name, _, child_name = module_name.rpartition(".")
+    if not parent_name:
+        return
+    parent = sys.modules.get(parent_name)
+    if parent is not None:
+        setattr(parent, child_name, module)
+
+
+def enable_playwright_compat() -> None:
+    """Enable legacy Playwright-compatible import names for this Python process.
+
+    After this is called, subsequent imports such as ``playwright.sync_api`` or
+    ``patchright.async_api`` resolve to Rustwright's compatibility shims.
+    """
+
+    global _ENABLED
+    if _ENABLED:
+        return
+
+    loaded_modules = [(alias_name, importlib.import_module(target_name)) for alias_name, target_name in _ALIASES]
+    for alias_name, module in loaded_modules:
+        _PREVIOUS_MODULES[alias_name] = sys.modules.get(alias_name)
+        sys.modules[alias_name] = module
+        _set_parent_attribute(alias_name, module)
+
+    _ENABLED = True
+
+
+def disable_playwright_compat() -> None:
+    """Undo aliases installed by :func:`enable_playwright_compat`."""
+
+    global _ENABLED
+    if not _ENABLED:
+        return
+
+    for alias_name, _target_name in _ALIASES:
+        previous = _PREVIOUS_MODULES.get(alias_name)
+        if previous is None:
+            sys.modules.pop(alias_name, None)
+        else:
+            sys.modules[alias_name] = previous
+            _set_parent_attribute(alias_name, previous)
+
+    _PREVIOUS_MODULES.clear()
+    _ENABLED = False
+
+
+__all__ = ["disable_playwright_compat", "enable_playwright_compat"]

rustwright/_compat/cloakbrowser/__init__.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from rustwright.async_api import async_playwright
+from rustwright.sync_api import sync_playwright
+
+_VALID_BACKENDS = {"playwright", "patchright"}
+
+
+def _resolve_backend(backend: Any = None) -> str:
+    value = backend if backend is not None else os.environ.get("CLOAKBROWSER_BACKEND", "playwright")
+    if not isinstance(value, str):
+        raise ValueError(f"Invalid cloakbrowser backend type: {type(value).__name__}")
+    normalized = value.strip().lower()
+    if normalized not in _VALID_BACKENDS:
+        raise ValueError(f"Invalid cloakbrowser backend: {value!r}. Must be one of {sorted(_VALID_BACKENDS)}")
+    return normalized
+
+
+def _normalize_proxy(proxy: Any) -> Any:
+    if isinstance(proxy, str):
+        return {"server": proxy}
+    return proxy
+
+
+def _normalize_common_options(options: dict[str, Any], *, persistent: bool) -> dict[str, Any]:
+    normalized = dict(options)
+    _resolve_backend(normalized.pop("backend", None))
+    normalized.pop("geoip", None)
+    normalized.pop("humanize", None)
+
+    if "proxy" in normalized:
+        normalized["proxy"] = _normalize_proxy(normalized["proxy"])
+
+    if persistent and "timezone" in normalized and "timezone_id" not in normalized:
+        normalized["timezone_id"] = normalized.pop("timezone")
+    else:
+        normalized.pop("timezone", None)
+
+    return normalized
+
+
+def ensure_binary(*, force: bool = False, **_: Any) -> str:
+    from rustwright.cli import _chromium_executable_path, _download_chromium
+
+    executable = _chromium_executable_path()
+    if executable and not force:
+        return executable
+    result = _download_chromium(force=force, dry_run=False)
+    return str(result["executable"])
+
+
+def launch(**kwargs: Any) -> Any:
+    manager = sync_playwright()
+    playwright = manager.start()
+    return playwright.chromium.launch(**_normalize_common_options(kwargs, persistent=False))
+
+
+async def launch_async(**kwargs: Any) -> Any:
+    manager = async_playwright()
+    playwright = await manager.start()
+    return await playwright.chromium.launch(**_normalize_common_options(kwargs, persistent=False))
+
+
+def launch_persistent_context(user_data_dir: str | Path, **kwargs: Any) -> Any:
+    manager = sync_playwright()
+    playwright = manager.start()
+    return playwright.chromium.launch_persistent_context(
+        user_data_dir,
+        **_normalize_common_options(kwargs, persistent=True),
+    )
+
+
+async def launch_persistent_context_async(user_data_dir: str | Path, **kwargs: Any) -> Any:
+    manager = async_playwright()
+    playwright = await manager.start()
+    return await playwright.chromium.launch_persistent_context(
+        user_data_dir,
+        **_normalize_common_options(kwargs, persistent=True),
+    )
+
+
+__all__ = [
+    "ensure_binary",
+    "launch",
+    "launch_async",
+    "launch_persistent_context",
+    "launch_persistent_context_async",
+]

rustwright/_compat/patchright/__init__.py

@@ -0,0 +1,2 @@
+from rustwright.sync_api import *  # noqa: F401,F403
+

rustwright/_compat/patchright/__main__.py

@@ -0,0 +1,5 @@
+from rustwright.cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(program="patchright"))

rustwright/_compat/patchright/_impl/__init__.py

@@ -0,0 +1 @@
+

rustwright/_compat/patchright/_impl/_errors.py

@@ -0,0 +1,4 @@
+from rustwright.sync_api import Error, TargetClosedError, TimeoutError
+
+__all__ = ["Error", "TargetClosedError", "TimeoutError"]
+

rustwright/_compat/patchright/async_api.py

@@ -0,0 +1,2 @@
+from rustwright.async_api import *  # noqa: F401,F403
+from rustwright.async_api import __all__ as __all__

rustwright/_compat/patchright/pytest_plugin.py

@@ -0,0 +1,2 @@
+from rustwright.pytest_plugin import *  # noqa: F401,F403
+

rustwright/_compat/patchright/sync_api.py

@@ -0,0 +1,2 @@
+from rustwright.sync_api import *  # noqa: F401,F403
+from rustwright.sync_api import __all__ as __all__

rustwright/_compat/playwright/__init__.py

@@ -0,0 +1,2 @@
+from rustwright.sync_api import *  # noqa: F401,F403
+

rustwright/_compat/playwright/__main__.py

@@ -0,0 +1,5 @@
+from rustwright.cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(program="playwright"))

rustwright/_compat/playwright/_impl/__init__.py

@@ -0,0 +1,2 @@
+"""Private Playwright compatibility namespace used by legacy integrations."""
+

rustwright/_compat/playwright/_impl/_errors.py

@@ -0,0 +1,4 @@
+from rustwright.sync_api import Error, TargetClosedError, TimeoutError
+
+__all__ = ["Error", "TargetClosedError", "TimeoutError"]
+

rustwright/_compat/playwright/async_api.py

@@ -0,0 +1,2 @@
+from rustwright.async_api import *  # noqa: F401,F403
+from rustwright.async_api import __all__ as __all__

rustwright/_compat/playwright/pytest_plugin.py

@@ -0,0 +1 @@
+from rustwright.pytest_plugin import *  # noqa: F401,F403

rustwright/_compat/playwright/sync_api.py

@@ -0,0 +1,2 @@
+from rustwright.sync_api import *  # noqa: F401,F403
+from rustwright.sync_api import __all__ as __all__

rustwright/_compat/pytest_playwright/__init__.py

@@ -0,0 +1,3 @@
+from .pytest_playwright import CreateContextCallback
+
+__all__ = ["CreateContextCallback"]

rustwright/_compat/pytest_playwright/py.typed

@@ -0,0 +1 @@
+

rustwright/_compat/pytest_playwright/pytest_playwright.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Literal, Optional, Pattern, Protocol, Sequence, Union
+
+from rustwright.pytest_plugin import *  # noqa: F401,F403
+from rustwright.sync_api import (
+    BrowserContext,
+    Geolocation,
+    HttpCredentials,
+    ProxySettings,
+    StorageState,
+    ViewportSize,
+)
+
+
+class CreateContextCallback(Protocol):
+    def __call__(
+        self,
+        viewport: Optional[ViewportSize] = None,
+        screen: Optional[ViewportSize] = None,
+        no_viewport: Optional[bool] = None,
+        ignore_https_errors: Optional[bool] = None,
+        java_script_enabled: Optional[bool] = None,
+        bypass_csp: Optional[bool] = None,
+        user_agent: Optional[str] = None,
+        locale: Optional[str] = None,
+        timezone_id: Optional[str] = None,
+        geolocation: Optional[Geolocation] = None,
+        permissions: Optional[Sequence[str]] = None,
+        extra_http_headers: Optional[Dict[str, str]] = None,
+        offline: Optional[bool] = None,
+        http_credentials: Optional[HttpCredentials] = None,
+        device_scale_factor: Optional[float] = None,
+        is_mobile: Optional[bool] = None,
+        has_touch: Optional[bool] = None,
+        color_scheme: Optional[Literal["dark", "light", "no-preference", "no-override", "null"]] = None,
+        reduced_motion: Optional[Literal["reduce", "no-preference", "no-override", "null"]] = None,
+        forced_colors: Optional[Literal["active", "none", "no-override", "null"]] = None,
+        contrast: Optional[Literal["no-preference", "more", "no-override"]] = None,
+        accept_downloads: Optional[bool] = None,
+        default_browser_type: Optional[str] = None,
+        proxy: Optional[ProxySettings] = None,
+        record_har_path: Optional[Union[str, Path]] = None,
+        record_har_omit_content: Optional[bool] = None,
+        record_video_dir: Optional[Union[str, Path]] = None,
+        record_video_size: Optional[ViewportSize] = None,
+        storage_state: Optional[Union[StorageState, str, Path]] = None,
+        base_url: Optional[str] = None,
+        strict_selectors: Optional[bool] = None,
+        service_workers: Optional[Literal["allow", "block"]] = None,
+        record_har_url_filter: Optional[Union[str, Pattern[str]]] = None,
+        record_har_mode: Optional[Literal["full", "minimal"]] = None,
+        record_har_content: Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: Optional[list[Any]] = None,
+    ) -> BrowserContext:
+        ...