244 lines
8.3 KiB
Python
244 lines
8.3 KiB
Python
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import typing
|
|
from enum import StrEnum
|
|
|
|
import structlog
|
|
from playwright.async_api import Frame, FrameLocator, Locator, Page
|
|
|
|
from skyvern.constants import INPUT_TEXT_TIMEOUT, SKYVERN_ID_ATTR
|
|
from skyvern.exceptions import (
|
|
ElementIsNotLabel,
|
|
ElementIsNotSelect2Dropdown,
|
|
MissingElement,
|
|
MissingElementDict,
|
|
MissingElementInCSSMap,
|
|
MissingElementInIframe,
|
|
MultipleElementsFound,
|
|
NoneFrameError,
|
|
SkyvernException,
|
|
)
|
|
from skyvern.forge.sdk.settings_manager import SettingsManager
|
|
from skyvern.webeye.scraper.scraper import ScrapedPage, get_select2_options
|
|
|
|
LOG = structlog.get_logger()
|
|
|
|
|
|
async def resolve_locator(
|
|
scrape_page: ScrapedPage, page: Page, frame: str, css: str
|
|
) -> typing.Tuple[Locator, Page | Frame]:
|
|
iframe_path: list[str] = []
|
|
|
|
while frame != "main.frame":
|
|
iframe_path.append(frame)
|
|
|
|
frame_element = scrape_page.id_to_element_dict.get(frame)
|
|
if frame_element is None:
|
|
raise MissingElement(element_id=frame)
|
|
|
|
parent_frame = frame_element.get("frame")
|
|
if not parent_frame:
|
|
raise SkyvernException(f"element without frame: {frame_element}")
|
|
|
|
LOG.info(f"{frame} is a child frame of {parent_frame}")
|
|
frame = parent_frame
|
|
|
|
current_page: Page | FrameLocator = page
|
|
current_frame: Page | Frame = page
|
|
|
|
while len(iframe_path) > 0:
|
|
child_frame = iframe_path.pop()
|
|
|
|
frame_handler = await current_frame.query_selector(f"[{SKYVERN_ID_ATTR}='{child_frame}']")
|
|
content_frame = await frame_handler.content_frame()
|
|
if content_frame is None:
|
|
raise NoneFrameError(frame_id=child_frame)
|
|
current_frame = content_frame
|
|
|
|
current_page = current_page.frame_locator(f"[{SKYVERN_ID_ATTR}='{child_frame}']")
|
|
|
|
return current_page.locator(css), current_frame
|
|
|
|
|
|
class InteractiveElement(StrEnum):
|
|
A = "a"
|
|
INPUT = "input"
|
|
SELECT = "select"
|
|
BUTTON = "button"
|
|
|
|
|
|
class SkyvernOptionType(typing.TypedDict):
|
|
optionIndex: int
|
|
text: str
|
|
|
|
|
|
class SkyvernElement:
|
|
"""
|
|
SkyvernElement is a python interface to interact with js elements built during the scarping.
|
|
When you try to interact with these elements by python, you are supposed to use this class as an interface.
|
|
"""
|
|
|
|
def __init__(self, locator: Locator, frame: Page | Frame, static_element: dict) -> None:
|
|
self.__static_element = static_element
|
|
self.__frame = frame
|
|
self.locator = locator
|
|
|
|
async def is_select2_dropdown(self) -> bool:
|
|
tag_name = self.get_tag_name()
|
|
element_class = await self.get_attr("class")
|
|
if element_class is None:
|
|
return False
|
|
return (
|
|
(tag_name == "a" and "select2-choice" in element_class)
|
|
or (tag_name == "span" and "select2-chosen" in element_class)
|
|
or (tag_name == "span" and "select2-arrow" in element_class)
|
|
or (tag_name == "input" and "select2-input" in element_class)
|
|
)
|
|
|
|
async def is_checkbox(self) -> bool:
|
|
tag_name = self.get_tag_name()
|
|
if tag_name != "input":
|
|
return False
|
|
|
|
button_type = await self.get_attr("type")
|
|
return button_type == "checkbox"
|
|
|
|
async def is_radio(self) -> bool:
|
|
tag_name = self.get_tag_name()
|
|
if tag_name != "input":
|
|
return False
|
|
|
|
button_type = await self.get_attr("type")
|
|
return button_type == "radio"
|
|
|
|
def get_tag_name(self) -> str:
|
|
return self.__static_element.get("tagName", "")
|
|
|
|
def get_id(self) -> str:
|
|
return self.__static_element.get("id", "")
|
|
|
|
def get_attributes(self) -> typing.Dict:
|
|
return self.__static_element.get("attributes", {})
|
|
|
|
def get_options(self) -> typing.List[SkyvernOptionType]:
|
|
options = self.__static_element.get("options", None)
|
|
if options is None:
|
|
return []
|
|
|
|
return typing.cast(typing.List[SkyvernOptionType], options)
|
|
|
|
def get_frame(self) -> Page | Frame:
|
|
return self.__frame
|
|
|
|
def get_locator(self) -> Locator:
|
|
return self.locator
|
|
|
|
async def get_select2_dropdown(self) -> Select2Dropdown:
|
|
if not await self.is_select2_dropdown():
|
|
raise ElementIsNotSelect2Dropdown(self.get_id(), self.__static_element)
|
|
|
|
return Select2Dropdown(self.get_frame(), self)
|
|
|
|
def find_element_id_in_label_children(self, element_type: InteractiveElement) -> str | None:
|
|
tag_name = self.get_tag_name()
|
|
if tag_name != "label":
|
|
raise ElementIsNotLabel(tag_name)
|
|
|
|
children: list[dict] = self.__static_element.get("children", [])
|
|
for child in children:
|
|
if not child.get("interactable"):
|
|
continue
|
|
|
|
if child.get("tagName") == element_type:
|
|
return child.get("id")
|
|
|
|
return None
|
|
|
|
async def get_attr(
|
|
self,
|
|
attr_name: str,
|
|
dynamic: bool = False,
|
|
timeout: float = SettingsManager.get_settings().BROWSER_ACTION_TIMEOUT_MS,
|
|
) -> typing.Any:
|
|
if not dynamic:
|
|
if attr := self.get_attributes().get(attr_name):
|
|
return attr
|
|
|
|
return await self.locator.get_attribute(attr_name, timeout=timeout)
|
|
|
|
async def input_sequentially(
|
|
self, text: str, default_timeout: float = SettingsManager.get_settings().BROWSER_ACTION_TIMEOUT_MS
|
|
) -> None:
|
|
await self.locator.press_sequentially(text, timeout=INPUT_TEXT_TIMEOUT)
|
|
|
|
|
|
class DomUtil:
|
|
"""
|
|
DomUtil is a python interface to interact with the DOM.
|
|
The ultimate goal here is to provide a full python-js interaction.
|
|
Some functions like wait_for_xxx should be supposed to define here.
|
|
"""
|
|
|
|
def __init__(self, scraped_page: ScrapedPage, page: Page) -> None:
|
|
self.scraped_page = scraped_page
|
|
self.page = page
|
|
|
|
async def get_skyvern_element_by_id(self, element_id: str) -> SkyvernElement:
|
|
element = self.scraped_page.id_to_element_dict.get(element_id)
|
|
if not element:
|
|
raise MissingElementDict(element_id)
|
|
|
|
frame = self.scraped_page.id_to_frame_dict.get(element_id)
|
|
if not frame:
|
|
raise MissingElementInIframe(element_id)
|
|
|
|
css = self.scraped_page.id_to_css_dict.get(element_id)
|
|
if not css:
|
|
raise MissingElementInCSSMap(element_id)
|
|
|
|
locator, frame_content = await resolve_locator(self.scraped_page, self.page, frame, css)
|
|
|
|
num_elements = await locator.count()
|
|
if num_elements < 1:
|
|
LOG.warning("No elements found with css. Validation failed.", css=css, element_id=element_id)
|
|
raise MissingElement(selector=css, element_id=element_id)
|
|
|
|
elif num_elements > 1:
|
|
LOG.warning(
|
|
"Multiple elements found with css. Expected 1. Validation failed.",
|
|
num_elements=num_elements,
|
|
selector=css,
|
|
element_id=element_id,
|
|
)
|
|
raise MultipleElementsFound(num=num_elements, selector=css, element_id=element_id)
|
|
|
|
return SkyvernElement(locator, frame_content, element)
|
|
|
|
|
|
class Select2Dropdown:
|
|
def __init__(self, frame: Page | Frame, skyvern_element: SkyvernElement) -> None:
|
|
self.skyvern_element = skyvern_element
|
|
self.frame = frame
|
|
|
|
async def open(self, timeout: float = SettingsManager.get_settings().BROWSER_ACTION_TIMEOUT_MS) -> None:
|
|
await self.skyvern_element.get_locator().click(timeout=timeout)
|
|
# wait for the options to load
|
|
await asyncio.sleep(3)
|
|
|
|
async def close(self, timeout: float = SettingsManager.get_settings().BROWSER_ACTION_TIMEOUT_MS) -> None:
|
|
await self.frame.locator("#select2-drop").press("Escape", timeout=timeout)
|
|
|
|
async def get_options(
|
|
self, timeout: float = SettingsManager.get_settings().BROWSER_ACTION_TIMEOUT_MS
|
|
) -> typing.List[SkyvernOptionType]:
|
|
element_handler = await self.skyvern_element.get_locator().element_handle(timeout=timeout)
|
|
options = await get_select2_options(self.frame, element_handler)
|
|
return typing.cast(typing.List[SkyvernOptionType], options)
|
|
|
|
async def select_by_index(
|
|
self, index: int, timeout: float = SettingsManager.get_settings().BROWSER_ACTION_TIMEOUT_MS
|
|
) -> None:
|
|
anchor = self.frame.locator("#select2-drop li[role='option']")
|
|
await anchor.nth(index).click(timeout=timeout)
|