inspect-ai 0.3.74__py3-none-any.whl → 0.3.76__py3-none-any.whl

inspect_ai/tool/_tools/_web_browser/_resources/web_client.py

@@ -1,214 +0,0 @@
-import argparse
-import sys
-from typing import Literal
-
-from constants import DEFAULT_SESSION_NAME, SERVER_PORT
-from rpc_client_helpers import RPCError, rpc_call
-from web_browser_rpc_types import (
-    ClickArgs,
-    CrawlerBaseArgs,
-    CrawlerResponse,
-    GoArgs,
-    NewSessionArgs,
-    NewSessionResponse,
-    ScrollArgs,
-    TypeOrSubmitArgs,
-)
-
-_SERVER_URL = f"http://localhost:{SERVER_PORT}/"
-
-
-def main() -> None:
-    if len(sys.argv) > 1:
-        command, params = _parse_args()
-        _execute_command(command, params)
-    else:
-        _interactive_mode()
-
-
-def _execute_command(
-    command: str,
-    params: NewSessionArgs
-    | GoArgs
-    | ClickArgs
-    | TypeOrSubmitArgs
-    | ScrollArgs
-    | CrawlerBaseArgs,
-) -> None:
-    try:
-        if command == "new_session":
-            print(
-                rpc_call(
-                    _SERVER_URL, command, dict(params), NewSessionResponse
-                ).session_name
-            )
-        else:
-            response = rpc_call(
-                _SERVER_URL,
-                command,
-                dict(params),
-                CrawlerResponse,
-            )
-            for key, value in vars(response).items():
-                if value is not None:
-                    print(key, ": ", value)
-
-    except RPCError as rpc_error:
-        _return_error(f"error: {rpc_error}")
-
-
-def _interactive_mode() -> None:
-    print(
-        "Welcome to the Playwright Crawler interactive mode!\n"
-        "commands:\n"
-        "  web_go <URL> - goes to the specified url.\n"
-        "  web_click <ELEMENT_ID> - clicks on a given element.\n"
-        "  web_scroll <up/down> - scrolls up or down one page.\n"
-        "  web_forward - navigates forward a page.\n"
-        "  web_back - navigates back a page.\n"
-        "  web_refresh - reloads current page (F5).\n"
-        "  web_type <ELEMENT_ID> <TEXT> - types the specified text into the input with the specified id.\n"
-        "  web_type_submit <ELEMENT_ID> <TEXT> - types the specified text into the input with the specified id and presses ENTER to submit the form."
-    )
-
-    session_created = False
-    while True:
-        try:
-            user_input = input("Enter command: ").strip()
-            if user_input.lower() in {"exit", "quit"}:
-                break
-            args = user_input.split()
-            sys.argv = ["cli"] + args
-            command, params = _parse_args()
-            print(f"command: {command}, params: {params}")
-            if not session_created:
-                _execute_command("new_session", NewSessionArgs(headful=True))
-                session_created = True
-            _execute_command(command, params)
-        except Exception as e:  # pylint: disable=broad-exception-caught
-            print(f"Error: {e}")
-
-
-def _return_error(error: str) -> None:
-    print(error, file=sys.stderr)
-    sys.exit(1)
-
-
-def _create_main_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="web_client")
-    parser.add_argument(
-        "--session_name",
-        type=str,
-        required=False,
-        default=DEFAULT_SESSION_NAME,
-        help="Session name",
-    )
-    return parser
-
-
-def _create_command_parser() -> argparse.ArgumentParser:
-    result = argparse.ArgumentParser(prog="web_client")
-
-    subparsers = result.add_subparsers(dest="command", required=True)
-
-    go_parser = subparsers.add_parser("web_go")
-    go_parser.add_argument("url", type=str, help="URL to navigate to")
-
-    click_parser = subparsers.add_parser("web_click")
-    click_parser.add_argument("element_id", type=str, help="ID of the element to click")
-
-    scroll_parser = subparsers.add_parser("web_scroll")
-    scroll_parser.add_argument(
-        "direction",
-        type=str,
-        choices=["up", "down"],
-        help="Direction to scroll (up or down)",
-    )
-    subparsers.add_parser("web_forward")
-    subparsers.add_parser("web_back")
-    subparsers.add_parser("web_refresh")
-
-    type_parser = subparsers.add_parser("web_type")
-    type_parser.add_argument(
-        "element_id", type=str, help="ID of the element to type into"
-    )
-    type_parser.add_argument("text", type=str, help="The text to type")
-
-    submit_parser = subparsers.add_parser("web_type_submit")
-    submit_parser.add_argument(
-        "element_id",
-        type=str,
-        help="ID of the element to type into and submit",
-    )
-    submit_parser.add_argument("text", type=str, help="The text to type")
-
-    # Add common argument to all subparsers
-    for name, subparser in subparsers.choices.items():
-        if name != "new_session":
-            subparser.add_argument(
-                "--session_name",
-                type=str,
-                nargs="?",
-                required=False,
-                default=DEFAULT_SESSION_NAME,
-                help="Session name",
-            )
-
-    return result
-
-
-main_parser = _create_main_parser()
-command_parser = _create_command_parser()
-
-
-def _parse_args() -> (
-    tuple[Literal["web_go"], GoArgs]
-    | tuple[Literal["web_click"], ClickArgs]
-    | tuple[Literal["web_type", "web_type_submit"], TypeOrSubmitArgs]
-    | tuple[Literal["web_scroll"], ScrollArgs]
-    | tuple[Literal["web_forward", "web_back", "web_refresh"], CrawlerBaseArgs]
-):
-    # web_client.py supports a very non-standard command line. It has a required named
-    # parameter, --session_name, before the command.
-    # Unfortunately, because we can't break backwards compatibility, we're stuck
-    # with that. To properly parse it, we'll be forced to have a separate parser
-    # for --session_name and merge the results with the normal command parser.
-
-    main_args, remaining_args = main_parser.parse_known_args()
-    session_name = main_args.session_name or DEFAULT_SESSION_NAME
-
-    command_args = command_parser.parse_args(remaining_args)
-    command_args_dict = vars(command_args)
-
-    match command_args.command:
-        case "web_go":
-            return command_args_dict["command"], GoArgs(
-                url=command_args_dict["url"],
-                session_name=session_name,
-            )
-        case "web_click":
-            return command_args_dict["command"], ClickArgs(
-                element_id=command_args_dict["element_id"],
-                session_name=session_name,
-            )
-        case "web_type" | "web_type_submit":
-            return command_args_dict["command"], TypeOrSubmitArgs(
-                element_id=command_args_dict["element_id"],
-                text=command_args_dict["text"],
-                session_name=session_name,
-            )
-        case "web_scroll":
-            return command_args_dict["command"], ScrollArgs(
-                direction=command_args_dict["direction"],
-                session_name=session_name,
-            )
-        case "web_forward" | "web_back" | "web_refresh":
-            return command_args_dict["command"], CrawlerBaseArgs(
-                session_name=session_name,
-            )
-        case _:
-            raise ValueError("Unexpected command")
-
-
-if __name__ == "__main__":
-    main()

inspect_ai/tool/_tools/_web_browser/_resources/web_client_new_session.py

@@ -1,35 +0,0 @@
-import argparse
-import sys
-
-from constants import SERVER_PORT
-from rpc_client_helpers import RPCError, rpc_call
-from web_browser_rpc_types import NewSessionArgs, NewSessionResponse
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(prog="web_client_new_session")
-    parser.add_argument(
-        "--headful", action="store_true", help="Run in headful mode for testing"
-    )
-    args_class = parser.parse_args()
-    args_dict = vars(args_class)
-    # TODO: Frick. this does no validation
-    params_typed_dict = NewSessionArgs(headful=args_dict["headful"])
-    params = dict(params_typed_dict)
-
-    try:
-        print(
-            rpc_call(
-                f"http://localhost:{SERVER_PORT}/",
-                "new_session",
-                params,
-                NewSessionResponse,
-            ).session_name
-        )
-    except RPCError as rpc_error:
-        print(rpc_error, file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

inspect_ai/tool/_tools/_web_browser/_resources/web_server.py

@@ -1,192 +0,0 @@
-import threading
-from typing import Awaitable, Callable, Unpack
-
-from aiohttp.web import Application, Request, Response, run_app
-from jsonrpcserver import Result, Success, async_dispatch, method
-
-from constants import DEFAULT_SESSION_NAME, SERVER_PORT
-from playwright_browser import PlaywrightBrowser
-from playwright_crawler import PlaywrightCrawler
-from scale_factor import get_screen_scale_factor
-from web_browser_rpc_types import (
-    ClickArgs,
-    CrawlerBaseArgs,
-    CrawlerResponse,
-    GoArgs,
-    NewSessionArgs,
-    NewSessionResponse,
-    ScrollArgs,
-    TypeOrSubmitArgs,
-)
-
-
-class Sessions:
-    def __init__(self) -> None:
-        self._lock = threading.Lock()
-        self._browser: PlaywrightBrowser | None = None
-        self._sessions: dict[str, PlaywrightCrawler] = {}
-
-    async def new_session(self, headful: bool) -> str:
-        with self._lock:
-            if not self._browser:
-                self._browser = await PlaywrightBrowser.create(headless=not headful)
-            current_count = len(self._sessions)
-            name = (
-                DEFAULT_SESSION_NAME
-                if current_count == 0
-                else f"{DEFAULT_SESSION_NAME}_{current_count}"
-            )
-            crawler = await PlaywrightCrawler.create(
-                await self._browser.get_new_context(),
-                device_scale_factor=get_screen_scale_factor() if headful else 1,
-            )
-            self._sessions[name] = crawler
-            return name
-
-    async def get_crawler_for_session(self, name: str) -> PlaywrightCrawler:
-        if not self._sessions:
-            await self.new_session(False)
-        return self._sessions[name]
-
-
-sessions = Sessions()
-
-
-@method
-async def new_session(**kwargs: Unpack[NewSessionArgs]) -> NewSessionResponse:
-    return Success(
-        NewSessionResponse(
-            session_name=await sessions.new_session(kwargs.get("headful", False))
-        ).model_dump()
-    )
-
-
-@method
-async def web_go(**kwargs: Unpack[GoArgs]) -> Result:
-    async def handler(crawler: PlaywrightCrawler):
-        await (await crawler.current_page).go_to_url(kwargs["url"])
-
-    return await _execute_crawler_command(kwargs["session_name"], handler)
-
-
-@method
-async def web_click(**kwargs: Unpack[ClickArgs]) -> Result:
-    async def handler(crawler: PlaywrightCrawler):
-        await (await crawler.current_page).click(kwargs["element_id"])
-
-    return await _execute_crawler_command(kwargs["session_name"], handler)
-
-
-@method
-async def web_scroll(**kwargs: Unpack[ScrollArgs]) -> Result:
-    async def handler(crawler: PlaywrightCrawler):
-        await (await crawler.current_page).scroll(kwargs["direction"])
-
-    return await _execute_crawler_command(kwargs["session_name"], handler)
-
-
-@method
-async def web_forward(**kwargs: Unpack[CrawlerBaseArgs]) -> Result:
-    async def handler(crawler: PlaywrightCrawler):
-        await (await crawler.current_page).forward()
-
-    return await _execute_crawler_command(kwargs["session_name"], handler)
-
-
-@method
-async def web_back(**kwargs: Unpack[CrawlerBaseArgs]) -> Result:
-    async def handler(crawler: PlaywrightCrawler):
-        await (await crawler.current_page).back()
-
-    return await _execute_crawler_command(kwargs["session_name"], handler)
-
-
-@method
-async def web_refresh(**kwargs: Unpack[CrawlerBaseArgs]) -> Result:
-    async def handler(crawler: PlaywrightCrawler):
-        await (await crawler.current_page).refresh()
-
-    return await _execute_crawler_command(kwargs["session_name"], handler)
-
-
-@method
-async def web_type(**kwargs: Unpack[TypeOrSubmitArgs]) -> Result:
-    async def handler(crawler: PlaywrightCrawler):
-        await (await crawler.current_page).type(
-            kwargs["element_id"], _str_from_str_or_list(kwargs["text"])
-        )
-
-    return await _execute_crawler_command(kwargs["session_name"], handler)
-
-
-@method
-async def web_type_submit(**kwargs: Unpack[TypeOrSubmitArgs]) -> Result:
-    async def handler(crawler: PlaywrightCrawler):
-        await (await crawler.current_page).clear(kwargs["element_id"])
-        await (await crawler.current_page).type(
-            kwargs["element_id"], _str_from_str_or_list(kwargs["text"]) + "\n"
-        )
-
-    return await _execute_crawler_command(kwargs["session_name"], handler)
-
-
-async def _execute_crawler_command(
-    session_name: str, handler: Callable[[PlaywrightCrawler], Awaitable[None]]
-) -> Result:
-    if not sessions:
-        await new_session()
-    try:
-        crawler = await sessions.get_crawler_for_session(session_name)
-        await handler(crawler)
-        await (await crawler.current_page).update()
-
-        # If there's a cookies message click to sort it out.
-        await _auto_click_cookies(crawler)
-
-        return Success(
-            CrawlerResponse(
-                web_url=(await crawler.current_page).url.split("?")[0],
-                main_content=(await crawler.current_page).render_main_content(),
-                web_at=(await crawler.current_page).render_at(),
-                error=None,
-            ).model_dump()
-        )
-    except Exception as e:  # pylint: disable=broad-exception-caught
-        return Success(
-            CrawlerResponse(
-                web_url=(await crawler.current_page).url.split("?")[0],
-                web_at="encountered error",
-                error=str(e),
-            ).model_dump()
-        )
-
-
-def _str_from_str_or_list(str_or_list: str | list[str]) -> str:
-    return str_or_list if isinstance(str_or_list, str) else " ".join(str_or_list)
-
-
-async def _auto_click_cookies(crawler: PlaywrightCrawler):
-    """Autoclick any cookies popup."""
-    try:
-        accept_node = (await crawler.current_page).lookup_node("<Accept all>")
-    except LookupError:
-        return
-    await (await crawler.current_page).click(accept_node.node_id)
-    await (await crawler.current_page).update()
-
-
-def main():
-    async def handle_request(request: Request) -> Response:
-        return Response(
-            text=await async_dispatch(await request.text()),
-            content_type="application/json",
-        )
-
-    app = Application()
-    app.router.add_post("/", handle_request)
-
-    run_app(app, port=SERVER_PORT)
-
-
-if __name__ == "__main__":
-    main()