cdpwave 0.1.0__py3-none-any.whl

cdpwave/client.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+from typing import Any
+
+from cdpwave.browser.discovery import TargetDiscovery, TargetInfo
+from cdpwave.browser.launcher import BrowserLauncher
+from cdpwave.domains.console import ConsoleDomain
+from cdpwave.domains.dom import DOMDomain
+from cdpwave.domains.log import LogDomain
+from cdpwave.domains.network import NetworkDomain
+from cdpwave.domains.page import PageDomain
+from cdpwave.domains.runtime import RuntimeDomain
+from cdpwave.domains.target import TargetDomain
+from cdpwave.events.dispatcher import EventDispatcher
+from cdpwave.events.handlers import EventHandler, Subscription
+from cdpwave.exceptions import SessionClosedError
+from cdpwave.session.manager import SessionManager
+from cdpwave.transport.connection import Connection
+from cdpwave.types import CommandSender
+
+logger = logging.getLogger("cdpwave.client")
+
+
+class CDPSession:
+    def __init__(
+        self,
+        connection: Connection,
+        session_id: str,
+        target_id: str,
+        client: CDPClient | None = None,
+    ) -> None:
+        self._connection = connection
+        self._session_id = session_id
+        self._target_id = target_id
+        self._closed = False
+        self._dispatcher = EventDispatcher()
+
+        if client is not None:
+            client._session_dispatchers[session_id] = self._dispatcher
+        self._client = client
+
+        async def _send(
+            method: str,
+            params: dict[str, Any] | None = None,
+        ) -> dict[str, Any]:
+            return await connection.send_command(
+                method,
+                params,
+                session_id=session_id,
+            )
+
+        self._sender: CommandSender = _send
+        self._page = PageDomain(self._sender)
+        self._runtime = RuntimeDomain(self._sender)
+        self._target = TargetDomain(self._sender)
+        self._network = NetworkDomain(self._sender)
+        self._dom = DOMDomain(self._sender)
+        self._log = LogDomain(self._sender)
+        self._console = ConsoleDomain(self._sender)
+
+    @property
+    def page(self) -> PageDomain:
+        return self._page
+
+    @property
+    def runtime(self) -> RuntimeDomain:
+        return self._runtime
+
+    @property
+    def target(self) -> TargetDomain:
+        return self._target
+
+    @property
+    def network(self) -> NetworkDomain:
+        return self._network
+
+    @property
+    def dom(self) -> DOMDomain:
+        return self._dom
+
+    @property
+    def log(self) -> LogDomain:
+        return self._log
+
+    @property
+    def console(self) -> ConsoleDomain:
+        return self._console
+
+    @property
+    def session_id(self) -> str:
+        return self._session_id
+
+    @property
+    def target_id(self) -> str:
+        return self._target_id
+
+    @property
+    def is_closed(self) -> bool:
+        return self._closed
+
+    async def send(
+        self,
+        method: str,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        if self._closed:
+            raise SessionClosedError(
+                f"Session {self._session_id} is closed"
+            )
+        return await self._sender(method, params)
+
+    async def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        self._dispatcher.clear()
+        if self._client is not None:
+            self._client._session_dispatchers.pop(self._session_id, None)
+        with contextlib.suppress(Exception):
+            await self._connection.send_command(
+                "Target.detachFromTarget",
+                {"sessionId": self._session_id},
+            )
+        logger.info("Session %s closed", self._session_id)
+
+    def on(self, event_name: str, handler: EventHandler) -> Subscription:
+        return self._dispatcher.on(event_name, handler)
+
+    def off(self, event_name: str, handler: EventHandler) -> None:
+        self._dispatcher.off(event_name, handler)
+
+    async def __aenter__(self) -> CDPSession:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: object,
+        exc_val: object,
+        exc_tb: object,
+    ) -> None:
+        await self.close()
+
+
+class CDPClient:
+    def __init__(
+        self,
+        connection: Connection,
+        launcher: BrowserLauncher | None = None,
+        discovery: TargetDiscovery | None = None,
+    ) -> None:
+        self._connection = connection
+        self._launcher = launcher
+        self._discovery = discovery
+        self._session_manager = SessionManager(connection)
+        self._dispatcher = EventDispatcher()
+        self._session_dispatchers: dict[str, EventDispatcher] = {}
+        self._sessions: dict[str, CDPSession] = {}
+        self._closed = False
+
+    async def _event_callback(
+        self,
+        event_name: str,
+        params: dict[str, Any],
+        session_id: str | None,
+    ) -> None:
+        if event_name == "Target.detachedFromTarget":
+            detached_session_id = params.get("sessionId")
+            if detached_session_id is not None:
+                session = self._sessions.get(detached_session_id)
+                if session is not None:
+                    session._closed = True
+                    session._dispatcher.clear()
+                    self._session_dispatchers.pop(detached_session_id, None)
+                    self._sessions.pop(detached_session_id, None)
+                    logger.info(
+                        "Session %s detached by browser",
+                        detached_session_id,
+                    )
+                else:
+                    logger.warning(
+                        "Target.detachedFromTarget for unknown session %s",
+                        detached_session_id,
+                    )
+            return
+
+        if session_id is None:
+            await self._dispatcher.dispatch(event_name, params)
+        else:
+            dispatcher = self._session_dispatchers.get(session_id)
+            if dispatcher is not None:
+                await dispatcher.dispatch(event_name, params)
+            else:
+                logger.warning(
+                    "Event %s for unknown session %s",
+                    event_name,
+                    session_id,
+                )
+
+    def on(self, event_name: str, handler: EventHandler) -> Subscription:
+        return self._dispatcher.on(event_name, handler)
+
+    def off(self, event_name: str, handler: EventHandler) -> None:
+        self._dispatcher.off(event_name, handler)
+
+    @classmethod
+    async def launch(
+        cls,
+        headless: bool = True,
+        browser_path: str | None = None,
+        port: int = 0,
+        user_data_dir: str | None = None,
+        extra_args: list[str] | None = None,
+        timeout: float = 10.0,
+    ) -> CDPClient:
+        launcher = BrowserLauncher(
+            browser_path=browser_path,
+            port=port,
+            headless=headless,
+            user_data_dir=user_data_dir,
+            extra_args=extra_args,
+        )
+        info = await launcher.launch(timeout=timeout)
+        discovery = TargetDiscovery(port=info.port)
+        client = cls.__new__(cls)
+        client._connection = Connection(
+            info.web_socket_debugger_url,
+            event_callback=client._event_callback,
+        )
+        await client._connection.connect()
+        client._launcher = launcher
+        client._discovery = discovery
+        client._session_manager = SessionManager(client._connection)
+        client._dispatcher = EventDispatcher()
+        client._session_dispatchers = {}
+        client._sessions = {}
+        client._closed = False
+        return client
+
+    @classmethod
+    async def connect(
+        cls,
+        host: str = "localhost",
+        port: int = 9222,
+    ) -> CDPClient:
+        discovery = TargetDiscovery(host=host, port=port)
+        version = await discovery.get_version()
+        client = cls.__new__(cls)
+        client._connection = Connection(
+            version.web_socket_debugger_url,
+            event_callback=client._event_callback,
+        )
+        await client._connection.connect()
+        client._launcher = None
+        client._discovery = discovery
+        client._session_manager = SessionManager(client._connection)
+        client._dispatcher = EventDispatcher()
+        client._session_dispatchers = {}
+        client._sessions = {}
+        client._closed = False
+        return client
+
+    async def new_page(self, url: str = "about:blank") -> CDPSession:
+        target_id = await self._session_manager.create_target(url)
+        session_id = await self._session_manager.attach_to_target(target_id)
+        session = CDPSession(
+            connection=self._connection,
+            session_id=session_id,
+            target_id=target_id,
+            client=self,
+        )
+        self._sessions[session_id] = session
+        return session
+
+    async def get_pages(self) -> list[TargetInfo]:
+        if self._discovery is None:
+            raise RuntimeError("Discovery is not available")
+        targets = await self._discovery.list_targets()
+        return [t for t in targets if t.type == "page"]
+
+    async def connect_to_page(self, target_id: str) -> CDPSession:
+        session_id = await self._session_manager.attach_to_target(target_id)
+        session = CDPSession(
+            connection=self._connection,
+            session_id=session_id,
+            target_id=target_id,
+            client=self,
+        )
+        self._sessions[session_id] = session
+        return session
+
+    async def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+
+        for session in list(self._sessions.values()):
+            with contextlib.suppress(Exception):
+                session._closed = True
+                session._dispatcher.clear()
+            self._session_dispatchers.pop(session._session_id, None)
+        self._sessions.clear()
+        self._dispatcher.clear()
+
+        with contextlib.suppress(Exception):
+            await self._connection.close()
+
+        if self._launcher is not None:
+            with contextlib.suppress(Exception):
+                await self._launcher.close()
+
+        logger.info("CDPClient closed")
+
+    @property
+    def is_closed(self) -> bool:
+        return self._closed or self._connection.is_closed
+
+    @property
+    def is_connected(self) -> bool:
+        return not self._connection.is_closed
+
+    async def __aenter__(self) -> CDPClient:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: object,
+        exc_val: object,
+        exc_tb: object,
+    ) -> None:
+        await self.close()

cdpwave/domains/base.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+from cdpwave.types import CommandSender
+
+
+class BaseDomain:
+    def __init__(self, send: CommandSender) -> None:
+        self._send = send
+
+    async def _call(
+        self,
+        method: str,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        return await self._send(method, params)

cdpwave/domains/console.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+from cdpwave.domains.base import BaseDomain
+
+
+class ConsoleDomain(BaseDomain):
+    async def enable(self) -> dict[str, Any]:
+        return await self._call("Console.enable")
+
+    async def disable(self) -> dict[str, Any]:
+        return await self._call("Console.disable")
+
+    async def clear_messages(self) -> dict[str, Any]:
+        return await self._call("Console.clearMessages")

cdpwave/domains/dom.py

@@ -0,0 +1,92 @@
+from typing import Any
+
+from cdpwave.domains.base import BaseDomain
+
+
+class DOMDomain(BaseDomain):
+    async def enable(self) -> dict[str, Any]:
+        return await self._call("DOM.enable")
+
+    async def disable(self) -> dict[str, Any]:
+        return await self._call("DOM.disable")
+
+    async def get_document(
+        self,
+        depth: int = -1,
+        pierce: bool = False,
+    ) -> dict[str, Any]:
+        return await self._call(
+            "DOM.getDocument",
+            {"depth": depth, "pierce": pierce},
+        )
+
+    async def get_outer_html(self, node_id: int) -> dict[str, Any]:
+        return await self._call(
+            "DOM.getOuterHTML",
+            {"nodeId": node_id},
+        )
+
+    async def get_inner_html(self, node_id: int) -> dict[str, Any]:
+        return await self._call(
+            "DOM.getInnerHTML",
+            {"nodeId": node_id},
+        )
+
+    async def query_selector(
+        self,
+        node_id: int,
+        selector: str,
+    ) -> dict[str, Any]:
+        return await self._call(
+            "DOM.querySelector",
+            {"nodeId": node_id, "selector": selector},
+        )
+
+    async def query_selector_all(
+        self,
+        node_id: int,
+        selector: str,
+    ) -> dict[str, Any]:
+        return await self._call(
+            "DOM.querySelectorAll",
+            {"nodeId": node_id, "selector": selector},
+        )
+
+    async def remove_node(self, node_id: int) -> dict[str, Any]:
+        return await self._call(
+            "DOM.removeNode",
+            {"nodeId": node_id},
+        )
+
+    async def set_attribute_value(
+        self,
+        node_id: int,
+        name: str,
+        value: str,
+    ) -> dict[str, Any]:
+        return await self._call(
+            "DOM.setAttributeValue",
+            {"nodeId": node_id, "name": name, "value": value},
+        )
+
+    async def get_attribute(
+        self,
+        node_id: int,
+        name: str,
+    ) -> dict[str, Any]:
+        return await self._call(
+            "DOM.getAttributes",
+            {"nodeId": node_id},
+        )
+
+    async def focus(self, node_id: int) -> dict[str, Any]:
+        return await self._call(
+            "DOM.focus",
+            {"nodeId": node_id},
+        )
+
+    async def scroll_into_view_if_needed(self, node_id: int) -> dict[str, Any]:
+        return await self._call(
+            "DOM.scrollIntoViewIfNeeded",
+            {"nodeId": node_id},
+        )

cdpwave/domains/log.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+from cdpwave.domains.base import BaseDomain
+
+
+class LogDomain(BaseDomain):
+    async def enable(self) -> dict[str, Any]:
+        return await self._call("Log.enable")
+
+    async def disable(self) -> dict[str, Any]:
+        return await self._call("Log.disable")
+
+    async def clear(self) -> dict[str, Any]:
+        return await self._call("Log.clear")
+
+    async def start_violation_report(
+        self,
+        config: list[dict[str, Any]],
+    ) -> dict[str, Any]:
+        return await self._call(
+            "Log.startViolationsReport",
+            {"config": config},
+        )
+
+    async def stop_violation_report(self) -> dict[str, Any]:
+        return await self._call("Log.stopViolationsReport")

cdpwave/domains/network.py

@@ -0,0 +1,141 @@
+from typing import Any
+
+from cdpwave.domains.base import BaseDomain
+
+
+class NetworkDomain(BaseDomain):
+    async def enable(
+        self,
+        max_total_buffer_size: int | None = None,
+        max_resource_buffer_size: int | None = None,
+        max_post_data_size: int | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {}
+        if max_total_buffer_size is not None:
+            params["maxTotalBufferSize"] = max_total_buffer_size
+        if max_resource_buffer_size is not None:
+            params["maxResourceBufferSize"] = max_resource_buffer_size
+        if max_post_data_size is not None:
+            params["maxPostDataSize"] = max_post_data_size
+        return await self._call("Network.enable", params or None)
+
+    async def disable(self) -> dict[str, Any]:
+        return await self._call("Network.disable")
+
+    async def set_user_agent_override(
+        self,
+        user_agent: str,
+        accept_language: str | None = None,
+        platform: str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"userAgent": user_agent}
+        if accept_language is not None:
+            params["acceptLanguage"] = accept_language
+        if platform is not None:
+            params["platform"] = platform
+        return await self._call("Network.setUserAgentOverride", params)
+
+    async def set_extra_request_headers(
+        self,
+        headers: dict[str, str],
+    ) -> dict[str, Any]:
+        return await self._call(
+            "Network.setExtraRequestHeaders",
+            {"headers": headers},
+        )
+
+    async def clear_browser_cookies(self) -> dict[str, Any]:
+        return await self._call("Network.clearBrowserCookies")
+
+    async def clear_browser_cache(self) -> dict[str, Any]:
+        return await self._call("Network.clearBrowserCache")
+
+    async def get_cookies(
+        self,
+        urls: list[str] | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {}
+        if urls is not None:
+            params["urls"] = urls
+        return await self._call("Network.getCookies", params or None)
+
+    async def set_cookie(
+        self,
+        name: str,
+        value: str,
+        url: str | None = None,
+        domain: str | None = None,
+        path: str | None = None,
+        secure: bool = False,
+        http_only: bool = False,
+        same_site: str | None = None,
+        expires: float | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {
+            "name": name,
+            "value": value,
+            "secure": secure,
+            "httpOnly": http_only,
+        }
+        if url is not None:
+            params["url"] = url
+        if domain is not None:
+            params["domain"] = domain
+        if path is not None:
+            params["path"] = path
+        if same_site is not None:
+            params["sameSite"] = same_site
+        if expires is not None:
+            params["expires"] = expires
+        return await self._call("Network.setCookie", params)
+
+    async def delete_cookies(
+        self,
+        name: str,
+        url: str | None = None,
+        domain: str | None = None,
+        path: str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"name": name}
+        if url is not None:
+            params["url"] = url
+        if domain is not None:
+            params["domain"] = domain
+        if path is not None:
+            params["path"] = path
+        return await self._call("Network.deleteCookies", params)
+
+    async def get_response_body(
+        self,
+        request_id: str,
+    ) -> dict[str, Any]:
+        return await self._call(
+            "Network.getResponseBody",
+            {"requestId": request_id},
+        )
+
+    async def set_cache_disabled(
+        self,
+        cache_disabled: bool,
+    ) -> dict[str, Any]:
+        return await self._call(
+            "Network.setCacheDisabled",
+            {"cacheDisabled": cache_disabled},
+        )
+
+    async def emulate_network_conditions(
+        self,
+        offline: bool = False,
+        latency: int = 0,
+        download_throughput: float = -1,
+        upload_throughput: float = -1,
+    ) -> dict[str, Any]:
+        return await self._call(
+            "Network.emulateNetworkConditions",
+            {
+                "offline": offline,
+                "latency": latency,
+                "downloadThroughput": download_throughput,
+                "uploadThroughput": upload_throughput,
+            },
+        )