persona-dsl 26.1.21.44__py3-none-any.whl

persona_dsl/ops/web/element_is_visible.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.pages.elements import Element
+
+
+class ElementIsVisible(Ops):
+    """
+    Бизнес-факт: проверить видимость элемента.
+    Приоритет поиска: по ARIA-роли и имени, затем по `locator`.
+    """
+
+    def __init__(self, element: Element):
+        if not isinstance(element, Element):
+            raise TypeError(
+                f"ElementIsVisible ожидает экземпляр Element, получено: {type(element)}"
+            )
+        self.element = element
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} проверяет видимость элемента '{self.element.name}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> bool:
+        """Возвращает True, если элемент видим."""
+        page = persona.skill(SkillId.BROWSER).page
+        return self.element.resolve(page).is_visible()

persona_dsl/ops/web/element_text.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.pages.elements import Element
+
+
+class ElementText(Ops):
+    """
+    Бизнес-факт: получить текстовое содержимое элемента.
+    Приоритет поиска: по ARIA-роли и имени, затем по `locator`.
+    """
+
+    def __init__(self, element: Element):
+        if not isinstance(element, Element):
+            raise TypeError(
+                f"ElementText ожидает экземпляр Element, получено: {type(element)}"
+            )
+        self.element = element
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} запрашивает текст элемента '{self.element.name}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> str:
+        """Возвращает текстовое содержимое элемента."""
+        page = persona.skill(SkillId.BROWSER).page
+        text = self.element.resolve(page).text_content()
+        return text or ""

persona_dsl/ops/web/elements_count.py

@@ -0,0 +1,42 @@
+from typing import Any, Union
+import copy
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.pages.elements import Element, ElementList
+
+
+class ElementsCount(Ops):
+    """
+    Бизнес-операция: подсчитать количество элементов, соответствующих прототипу.
+
+    Принимает:
+      - Element: будет посчитано количество совпадений для данного описания элемента.
+      - ElementList: используется его прототип для построения локатора и подсчёта.
+    """
+
+    def __init__(self, element_or_list: Union[Element, ElementList]):
+        if isinstance(element_or_list, ElementList):
+            self._element = (
+                element_or_list._prototype
+            )  # noqa: SLF001 (осознанный доступ к прототипу)
+        elif isinstance(element_or_list, Element):
+            self._element = element_or_list
+        else:
+            raise TypeError("ElementsCount ожидает Element или ElementList")
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} подсчитывает количество элементов для '{self._element.name}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> int:
+        page = persona.skill(SkillId.BROWSER).page
+        # Базовый локатор — родитель, если он есть; иначе вся страница
+        base = self._element.parent.resolve(page) if self._element.parent else page
+
+        # Строим локатор для всех совпадений (index=None)
+        # Using copy and modifying the copy is safer and more robust than manual constructor
+        probe = copy.copy(self._element)
+        probe.index = None
+
+        locator = probe._get_playwright_locator(base)
+        return locator.count()

persona_dsl/ops/web/fill.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.pages.elements import Element
+
+
+class Fill(Ops):
+    """
+    Атомарное действие: заполнить поле текстом.
+    Приоритет поиска: по ARIA-роли и имени, затем по `locator`.
+    Поддерживает проброс аргументов в Playwright (force, timeout, etc).
+    """
+
+    def __init__(self, element: Element, text: str, **kwargs: Any):
+        if not isinstance(element, Element):
+            raise TypeError(
+                f"Fill ожидает экземпляр Element, получено: {type(element)}"
+            )
+        self.element = element
+        self.text = text
+        self.kwargs = kwargs
+
+    def _get_step_description(self, persona: Any) -> str:
+        # Не логируем пароли и другие чувствительные данные
+        text_to_log = self.text
+        name_lower = self.element.name.lower()
+        accessible_name_lower = (self.element.accessible_name or "").lower()
+        if (
+            "password" in name_lower
+            or "pass" in name_lower
+            or "парол" in accessible_name_lower
+        ):
+            text_to_log = "****"
+        extra = f" с параметрами {self.kwargs}" if self.kwargs else ""
+        return f"{persona} заполняет поле '{self.element.name}' текстом '{text_to_log}'{extra}"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> None:
+        page = persona.skill(SkillId.BROWSER).page
+        locator = self.element.resolve(page)
+        locator.fill(self.text, **self.kwargs)

persona_dsl/ops/web/generate_page_object.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any, Optional
+from urllib.parse import urlparse
+
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.generators.page_generator import PageGenerator
+from persona_dsl.utils.naming import to_snake_case
+from .rich_aria_snapshot import RichAriaSnapshot
+
+
+class GeneratePageObject(Ops):
+    """
+    Бизнес-операция: сгенерировать и сохранить PageObject на основе текущего состояния страницы.
+    Работает при запуске pytest с флагом --generate-pages (см. pytest_plugin.py).
+
+    По умолчанию также сохраняет ARIA-снепшот в tests/pages/aria/<stem>_snapshot.yaml
+    и прокидывает относительный путь в сгенерированный Page (static_aria_snapshot_path).
+
+    Параметры ожидания перед генерацией регулируются аргументами:
+      - wait_for_state: состояние загрузки Playwright ('load' | 'domcontentloaded' | 'networkidle' | 'commit')
+      - wait_timeout: таймаут в миллисекундах; если None — используется дефолтный таймаут Playwright/страницы
+      - sleep_before: если задано (в секундах), выполнить простую паузу перед генерацией и не ждать состояние загрузки
+    """
+
+    def __init__(
+        self,
+        class_name: str = "GeneratedPage",
+        output_path: Optional[str] = None,
+        wait_for_state: Optional[str] = "networkidle",
+        wait_timeout: Optional[float] = None,
+        sleep_before: Optional[float] = None,
+    ):
+        self.class_name = class_name or "GeneratedPage"
+        if output_path is None:
+            file_name = f"{to_snake_case(self.class_name)}.py"
+            # Дефолт как у клиента: tests/pages/
+            self.output_path = Path("tests/pages") / file_name
+        else:
+            self.output_path = Path(output_path)
+        self.wait_for_state = wait_for_state
+        self.wait_timeout = wait_timeout
+        self.sleep_before = sleep_before
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} генерирует PageObject '{self.class_name}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> None:
+        # Проверяем флаг в pytest (регистрируется в pytest_plugin.py)
+        request = getattr(persona, "_pytest_request", None)
+        generate_enabled = False
+        if request is not None:
+            try:
+                generate_enabled = bool(request.config.getoption("--generate-pages"))
+            except Exception:
+                generate_enabled = False
+
+        if not generate_enabled:
+            # Явный no-op без побочных эффектов
+            return
+
+        browser_skill = persona.skill(SkillId.BROWSER)
+        page = browser_skill.page
+
+        # Варианты ожидания перед генерацией: простая пауза или ожидание состояния
+        if self.sleep_before is not None:
+            time.sleep(self.sleep_before)
+        elif self.wait_for_state:
+            if self.wait_timeout is None:
+                page.wait_for_load_state(self.wait_for_state)
+            else:
+                page.wait_for_load_state(self.wait_for_state, timeout=self.wait_timeout)
+
+        # Получаем относительный путь URL
+        page_path = urlparse(page.url).path
+
+        # Используем rich ARIA snapshot вместо стандартного
+        rich_snapshot_op = RichAriaSnapshot()
+        snapshot_struct = rich_snapshot_op.get_tree(persona)
+
+        # Сохраняем ARIA снепшот на диск как YAML-строку
+        assets_dir = self.output_path.parent / "aria"
+        assets_dir.mkdir(parents=True, exist_ok=True)
+
+        snapshot_file = f"{self.output_path.stem}_snapshot.yaml"
+        snapshot_abs_path = assets_dir / snapshot_file
+
+        snapshot_yaml: str = (
+            RichAriaSnapshot.to_yaml(snapshot_struct) if snapshot_struct else ""
+        )
+        if snapshot_yaml:
+            snapshot_abs_path.write_text(snapshot_yaml, encoding="utf-8")
+        aria_snapshot_rel_path = f"aria/{snapshot_file}"
+
+        generator = PageGenerator()
+
+        # Если файл уже существует — читаем его и выполняем умное обновление (merge)
+        existing_code: Optional[str] = None
+        try:
+            if self.output_path.exists():
+                existing_code = self.output_path.read_text(encoding="utf-8")
+        except Exception:
+            existing_code = None
+
+        generated_code = generator.generate_or_update_from_aria_snapshot(
+            snapshot=snapshot_struct,
+            class_name=self.class_name,
+            page_path=page_path,
+            aria_snapshot_path=aria_snapshot_rel_path,
+            existing_code=existing_code,
+        )
+
+        self.output_path.parent.mkdir(parents=True, exist_ok=True)
+        self.output_path.write_text(generated_code, encoding="utf-8")

persona_dsl/ops/web/input_value.py

@@ -0,0 +1,23 @@
+from typing import Any
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.pages.elements import Element
+
+
+class InputValue(Ops):
+    """
+    Бизнес-операция: получить текущее значение из поля ввода (input/textarea/select).
+    Использует Playwright Locator.input_value() для корректного чтения значения.
+    """
+
+    def __init__(self, element: Element):
+        self.element = element
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} запрашивает значение поля ввода '{self.element.name}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> str:
+        page = persona.skill(SkillId.BROWSER).page
+        locator = self.element.resolve(page)
+        return locator.input_value()

persona_dsl/ops/web/navigate.py

@@ -0,0 +1,52 @@
+from typing import Any, TYPE_CHECKING, Union
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+
+if TYPE_CHECKING:
+    from persona_dsl.pages.page import Page
+
+
+class NavigateTo(Ops):
+    """
+    Атомарное действие: перейти по адресу.
+    LCL-39: Поддержка build_url для Page.
+    """
+
+    def __init__(self, target: Union[str, "Page"]):
+        self._target = target
+
+    def _resolve_path(self, page_skill: Any) -> str:
+        if isinstance(self._target, str):
+            return self._target
+
+        # Duck-typing: ожидаем Page
+        page_obj = self._target
+
+        if hasattr(page_obj, "build_url"):
+            # Получаем base_url из контекста браузера (если возможно)
+            # Но base_url в playwright хранится в context или page?
+            # page.context.base_url?
+            # Для простоты пока передаем None, так как goto сам резолвит относительно base_url,
+            # если передан относительный путь.
+            # Но если build_url возвращает полный URL, то все ок.
+            return page_obj.build_url()
+
+        expected_path = getattr(page_obj, "expected_path", None)
+        if not isinstance(expected_path, str) or not expected_path:
+            raise ValueError(
+                "NavigateTo: у переданной страницы не задан expected_path."
+            )
+        return expected_path
+
+    def _get_step_description(self, persona: Any) -> str:
+        # Для описания мы не можем резолвить base_url, покажем относительный
+        path = str(self._target)
+        if hasattr(self._target, "expected_path"):
+            path = getattr(self._target, "expected_path")
+        return f"{persona} переходит по адресу '{path}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> None:
+        browser_skill = persona.skill(SkillId.BROWSER)
+        url_or_path = self._resolve_path(browser_skill)
+        browser_skill.page.goto(url_or_path)

persona_dsl/ops/web/press_key.py

@@ -0,0 +1,37 @@
+from typing import Any
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.pages.elements import Element
+
+
+class PressKey(Ops):
+    """
+    Атомарное действие: нажать клавишу на элементе.
+    Приоритет поиска: по ARIA-роли и имени, затем по `locator`.
+    Поддерживает проброс аргументов в Playwright (timeout, no_wait_after, etc).
+    """
+
+    def __init__(self, element: Element, key: str, **kwargs: Any):
+        """
+        Args:
+            element: Экземпляр элемента, на котором нажимается клавиша.
+            key: Имя клавиши для нажатия (например, 'Enter', 'Tab', 'ArrowDown').
+            **kwargs: Дополнительные аргументы для Playwright locator.press().
+        """
+        if not isinstance(element, Element):
+            raise TypeError(
+                f"PressKey ожидает экземпляр Element, получено: {type(element)}"
+            )
+        self.element = element
+        self.key = key
+        self.kwargs = kwargs
+
+    def _get_step_description(self, persona: Any) -> str:
+        extra = f" с параметрами {self.kwargs}" if self.kwargs else ""
+        return f"{persona} нажимает клавишу '{self.key}' на элементе '{self.element.name}'{extra}"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> None:
+        page = persona.skill(SkillId.BROWSER).page
+        locator = self.element.resolve(page)
+        locator.press(self.key, **self.kwargs)

persona_dsl/ops/web/rich_aria_snapshot.py

@@ -0,0 +1,159 @@
+"""Богатый ARIA-снепшот с использованием Persona Runtime (JS Kernel)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+import allure
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+
+
+class RichAriaSnapshot(Ops):
+    """
+    Факт: получить богатый ARIA-снепшот всей страницы.
+    Использует внедренное JS-ядро (window.__PERSONA__) для получения дерева,
+    затем рендерит его в YAML-формат, совместимый с Playwright/MCP.
+    """
+
+    def __init__(self, timeout: float | None = None) -> None:
+        self.timeout = timeout
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} получает богатый ARIA-снепшот страницы (через Runtime)"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> str:
+        """
+        Выполняет операцию получения снепшота.
+        Returns:
+            str: YAML-строка снепшота (как в Playwright).
+        """
+        snapshot_tree = self.get_tree(persona)
+
+        # 2. Рендерим YAML для отчетов (визуализация)
+        snapshot_yaml = self.to_yaml(snapshot_tree)
+
+        try:
+            allure.attach(
+                snapshot_yaml,
+                name="rich-aria-page",
+                attachment_type=allure.attachment_type.YAML,
+            )
+        except Exception:
+            pass
+
+        return snapshot_yaml
+
+    def get_tree(self, persona: Any) -> Dict[str, Any] | List[Any]:
+        """
+        Получает сырое дерево элементов (dict/list) от Persona Runtime.
+        Используется в генераторах кода.
+        """
+        page = persona.skill(SkillId.BROWSER).page
+
+        # 1. Получаем чистое JSON-дерево от ядра
+        snapshot_tree = page.evaluate(
+            "window.__PERSONA__ && window.__PERSONA__.getTreeForTransport && window.__PERSONA__.getTreeForTransport()"
+        )
+
+        if not snapshot_tree:
+            raise RuntimeError(
+                "Persona Runtime не вернул JSON-дерево (getTreeForTransport). Убедитесь, что Runtime инициализирован."
+            )
+
+        return snapshot_tree
+
+    @staticmethod
+    def to_yaml(root: Dict[str, Any] | List[Any]) -> str:
+        """
+        Преобразует JSON-дерево в читаемый структурный YAML формат.
+        Формат:
+        role "name" [ref=...]:
+          - /props...
+          - children...
+        """
+        lines = []
+        if isinstance(root, dict):
+            lines.extend(RichAriaSnapshot._render_node_yaml(root, indent=0))
+        elif isinstance(root, list):
+            for node in root:
+                lines.extend(RichAriaSnapshot._render_node_yaml(node, indent=0))
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def _render_node_yaml(node: Dict[str, Any] | str, indent: int) -> List[str]:
+        if isinstance(node, str):
+            # Текстовый узел (строка)
+            return [f"{'  ' * indent}- \"{node}\""]
+
+        lines = []
+        prefix = "  " * indent
+
+        role = node.get("role", "generic")
+        name = node.get("name", "")
+        ref = node.get("ref")
+
+        # Формируем заголовок узла
+        # Пример: - combobox "Bank" [ref=xyz]
+
+        # Экранирование имени
+        safe_name = ""
+        if name:
+            escaped_name = name.replace("`", "").replace('"', '\\"')
+            safe_name = f' "{escaped_name}"'
+
+        ref_str = f" [ref={ref}]" if ref else ""
+
+        # Собираем пропы, которые надо показать в строке (статусы)
+        status_parts = []
+        # ARIA/состояния из Runtime кладутся на корень узла, а не в props
+        if node.get("checked") is True:
+            status_parts.append("[checked]")
+        elif node.get("checked") == "mixed":
+            status_parts.append("[checked=mixed]")
+
+        if node.get("pressed") is True:
+            status_parts.append("[pressed]")
+        elif node.get("pressed") == "mixed":
+            status_parts.append("[pressed=mixed]")
+
+        if node.get("disabled"):
+            status_parts.append("[disabled]")
+        if node.get("expanded") is True:
+            status_parts.append("[expanded]")
+        if node.get("selected"):
+            status_parts.append("[selected]")
+        if node.get("level") is not None:
+            status_parts.append(f"[level={node['level']}]")
+        # Поле hidden помечает элементы, скрытые визуально/по ARIA
+        if node.get("hidden"):
+            status_parts.append("[hidden]")
+
+        status_str = " ".join(status_parts)
+        if status_str:
+            status_str = " " + status_str
+
+        # Основная строка узла
+        header = f"{prefix}- {role}{safe_name}{ref_str}{status_str}:"
+
+        children = node.get("children", [])
+        props = node.get("props", {})
+
+        # Если нет детей и пропов, убираем двоеточие
+        if not children and not props:
+            header = header.rstrip(":")
+            lines.append(header)
+        else:
+            lines.append(header)
+
+            # Рендерим props
+            for k, v in props.items():
+                if v:  # Не выводим пустые пропы
+                    lines.append(f'{prefix}  - /{k}: "{v}"')
+
+            # Рендерим детей
+            for child in children:
+                lines.extend(RichAriaSnapshot._render_node_yaml(child, indent + 1))
+
+        return lines

persona_dsl/ops/web/screenshot.py

@@ -0,0 +1,68 @@
+import time
+from typing import Any, Optional
+
+import allure
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.utils.artifacts import sanitize_filename, screenshots_dir
+from persona_dsl.pages.elements import Element
+
+
+class PageScreenshot(Ops):
+    """
+    Факт: сделать скриншот текущей страницы.
+    Возвращает путь к PNG-файлу.
+    """
+
+    def __init__(
+        self, name: str, full_page: bool = False, omit_background: bool = False
+    ):
+        self.name = name
+        self.full_page = full_page
+        self.omit_background = omit_background
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} делает скриншот страницы '{self.name}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> str:
+        page = persona.skill(SkillId.BROWSER).page
+        ts = int(time.time() * 1000)
+        base_name = sanitize_filename(self.name)
+        path = screenshots_dir() / f"{ts}-{base_name}.png"
+        page.screenshot(
+            path=str(path),
+            full_page=self.full_page,
+            omit_background=self.omit_background,
+        )
+        allure.attach.file(
+            str(path), name=base_name, attachment_type=allure.attachment_type.PNG
+        )
+        return str(path)
+
+
+class ElementScreenshot(Ops):
+    """
+    Факт: сделать скриншот элемента.
+    Возвращает путь к PNG-файлу.
+    """
+
+    def __init__(self, element: Element, name: Optional[str] = None):
+        self.element = element
+        self.name = name or element.name
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} делает скриншот элемента '{self.element.name}' как '{self.name}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> str:
+        page = persona.skill(SkillId.BROWSER).page
+        ts = int(time.time() * 1000)
+        base_name = sanitize_filename(self.name)
+        path = screenshots_dir() / f"{ts}-{base_name}.png"
+
+        locator = self.element.resolve(page)
+        locator.screenshot(path=str(path))
+        allure.attach.file(
+            str(path), name=base_name, attachment_type=allure.attachment_type.PNG
+        )
+        return str(path)

persona_dsl/ops/web/table_data.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict, List
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.pages.elements import Table
+
+
+class TableData(Ops):
+    """
+    Извлекает данные из таблицы в виде списка словарей.
+    Ключи — заголовки столбцов, значения — текст ячеек.
+    """
+
+    def __init__(self, table_element: Table):
+        self.table = table_element
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} извлекает данные из таблицы '{self.table.name}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> List[Dict[str, str]]:
+        page = persona.skill(SkillId.BROWSER).page
+        table_locator = self.table.resolve(page)
+
+        # Заголовки
+        header_locators = table_locator.locator("th, [role=columnheader]").all()
+        headers = [(h.text_content() or "").strip() for h in header_locators]
+
+        data: List[Dict[str, str]] = []
+
+        # Строки таблицы (постараемся избегать header-строк)
+        rows_locator = table_locator.locator("tbody tr, tr[role=row], :scope > tr")
+        for row in rows_locator.all():
+            cell_locs = row.locator("td, [role=cell], th, [role=rowheader]").all()
+            # Берём только строки, где количество ячеек равно количеству заголовков
+            if headers and len(cell_locs) == len(headers):
+                row_dict: Dict[str, str] = {}
+                for i, cell in enumerate(cell_locs):
+                    text = (cell.text_content() or "").strip()
+                    row_dict[headers[i]] = text
+                if any(v for v in row_dict.values()):
+                    data.append(row_dict)
+
+        return data

persona_dsl/ops/web/wait_for_navigation.py

@@ -0,0 +1,23 @@
+from typing import Any, Optional
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+
+
+class WaitForNavigation(Ops):
+    """
+    Атомарное действие: дождаться загрузки страницы/сети.
+
+    По умолчанию ждём состояния 'networkidle' для стабильности перед дальнейшими действиями/генерацией.
+    """
+
+    def __init__(self, state: str = "networkidle", timeout: Optional[float] = 60000):
+        self.state = state
+        self.timeout = timeout
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} ожидает состояние загрузки страницы '{self.state}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> None:
+        page = persona.skill(SkillId.BROWSER).page
+        page.wait_for_load_state(self.state, timeout=self.timeout)