persona-dsl 26.1.21.44__py3-none-any.whl

persona_dsl/ops/api/__init__.py

@@ -0,0 +1,5 @@
+from .send_request import SendRequest
+from .json_response import JsonResponse
+from .json_as import JsonAs
+
+__all__ = ["SendRequest", "JsonResponse", "JsonAs"]

persona_dsl/ops/api/json_as.py

@@ -0,0 +1,104 @@
+from typing import Any, Optional, Dict
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.skills.use_api import UseAPI
+
+
+class JsonAs(Ops):
+    """
+    Низкоуровневая операция: делает HTTP-запрос и валидирует JSON-ответ как указанный тип.
+    Использует типизированные методы UseAPI (get_json_as/post_json_as/...).
+    Возвращает типизированный объект согласно model_type.
+    """
+
+    def __init__(
+        self,
+        method: str,
+        path: str,
+        model_type: Any,
+        json: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ):
+        self.method = method
+        self.path = path
+        self.model_type = model_type
+        self.json = json
+        self.params = params
+        self.headers = headers
+        self.kwargs = kwargs
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} запрашивает {self.method.upper()} '{self.path}' и парсит JSON как {getattr(self.model_type, '__name__', str(self.model_type))}"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> Any:
+        api: UseAPI = persona.skill(SkillId.API)
+        m = self.method.upper()
+        if m == "GET":
+            return api.get_json_as(
+                self.path,
+                self.model_type,
+                params=self.params,
+                headers=self.headers,
+                json=self.json,
+                **self.kwargs,
+            )
+        if m == "POST":
+            return api.post_json_as(
+                self.path,
+                self.model_type,
+                params=self.params,
+                headers=self.headers,
+                json=self.json,
+                **self.kwargs,
+            )
+        if m == "PUT":
+            return api.put_json_as(
+                self.path,
+                self.model_type,
+                params=self.params,
+                headers=self.headers,
+                json=self.json,
+                **self.kwargs,
+            )
+        if m == "PATCH":
+            return api.patch_json_as(
+                self.path,
+                self.model_type,
+                params=self.params,
+                headers=self.headers,
+                json=self.json,
+                **self.kwargs,
+            )
+        if m == "DELETE":
+            return api.delete_json_as(
+                self.path,
+                self.model_type,
+                params=self.params,
+                headers=self.headers,
+                json=self.json,
+                **self.kwargs,
+            )
+        # Для прочих методов (HEAD/OPTIONS) пробуем соответствующие typed-методы, если они вернут None — так и вернём
+        if m == "HEAD":
+            return api.head_json_as(
+                self.path,
+                self.model_type,
+                params=self.params,
+                headers=self.headers,
+                json=self.json,
+                **self.kwargs,
+            )
+        if m == "OPTIONS":
+            return api.options_json_as(
+                self.path,
+                self.model_type,
+                params=self.params,
+                headers=self.headers,
+                json=self.json,
+                **self.kwargs,
+            )
+        # Явная ошибка для неподдерживаемых методов
+        raise ValueError(f"JsonAs: неподдерживаемый метод {self.method}")

persona_dsl/ops/api/json_response.py

@@ -0,0 +1,48 @@
+from typing import Any, Optional, Dict
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.skills.use_api import UseAPI
+
+
+class JsonResponse(Ops):
+    """
+    Низкоуровневая операция: получает тело JSON-ответа после отправки запроса.
+    Этот факт предполагает, что запрос УЖЕ был отправлен (например, через SendRequest),
+    и мы работаем с последним ответом. В реальной реализации лучше объединить
+    отправку и получение ответа в один Fact.
+
+    Примечание: Для практического использования лучше создать Fact, который
+    сам делает запрос и возвращает результат.
+    """
+
+    def __init__(
+        self,
+        method: str,
+        path: str,
+        json: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ):
+        self.method = method
+        self.path = path
+        self.json = json
+        self.params = params
+        self.headers = headers
+        self.kwargs = kwargs
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} получает JSON-ответ от {self.method.upper()} '{self.path}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> Any:
+        api: UseAPI = persona.skill(SkillId.API)
+        response = api._request(
+            method=self.method,
+            path=self.path,
+            json=self.json,
+            params=self.params,
+            headers=self.headers,
+            **self.kwargs,
+        )
+        return response.json()

persona_dsl/ops/api/send_request.py

@@ -0,0 +1,41 @@
+from typing import Any, Optional, Dict
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.skills.use_api import UseAPI
+
+
+class SendRequest(Ops):
+    """
+    Низкоуровневая операция: отправляет HTTP-запрос.
+    """
+
+    def __init__(
+        self,
+        method: str,
+        path: str,
+        json: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ):
+        self.method = method
+        self.path = path
+        self.json = json
+        self.params = params
+        self.headers = headers
+        self.kwargs = kwargs
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} отправляет {self.method.upper()} запрос на '{self.path}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> None:
+        api: UseAPI = persona.skill(SkillId.API)
+        api._request(
+            method=self.method,
+            path=self.path,
+            json=self.json,
+            params=self.params,
+            headers=self.headers,
+            **self.kwargs,
+        )

persona_dsl/ops/db/__init__.py

@@ -0,0 +1,5 @@
+from .execute_sql import ExecuteSQL
+from .fetch_one import FetchOne
+from .fetch_all import FetchAll
+
+__all__ = ["ExecuteSQL", "FetchOne", "FetchAll"]

persona_dsl/ops/db/execute_sql.py

@@ -0,0 +1,22 @@
+from typing import Any, Optional
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.skills.use_database import UseDatabase
+
+
+class ExecuteSQL(Ops):
+    """
+    Низкоуровневая операция: выполняет SQL-запрос без возврата результата.
+    """
+
+    def __init__(self, query: str, params: Optional[Any] = None):
+        self.query = query
+        self.params = params
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} выполняет SQL-запрос: {self.query[:100]}"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> None:
+        db: UseDatabase = persona.skill(SkillId.DB)
+        db.execute(self.query, self.params)

persona_dsl/ops/db/fetch_all.py

@@ -0,0 +1,29 @@
+from typing import Any, Optional, List
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.skills.use_database import UseDatabase
+
+
+class FetchAll(Ops):
+    """
+    Низкоуровневая операция: выполняет SQL-запрос и возвращает все строки.
+    """
+
+    def __init__(self, query: str, params: Optional[Any] = None):
+        self.query = query
+        self.params = params
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} получает все записи по SQL-запросу: {self.query[:100]}"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> List[Any]:
+        db: UseDatabase = persona.skill(SkillId.DB)
+        conn = db.get_connection()
+        cursor = conn.cursor()
+        try:
+            cursor.execute(self.query, self.params or ())
+            result = cursor.fetchall()
+            return result
+        finally:
+            cursor.close()

persona_dsl/ops/db/fetch_one.py

@@ -0,0 +1,22 @@
+from typing import Any, Optional
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.skills.use_database import UseDatabase
+
+
+class FetchOne(Ops):
+    """
+    Низкоуровневая операция: выполняет SQL-запрос и возвращает первую строку.
+    """
+
+    def __init__(self, query: str, params: Optional[Any] = None):
+        self.query = query
+        self.params = params
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} получает одну запись по SQL-запросу: {self.query[:100]}"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> Any:
+        db: UseDatabase = persona.skill(SkillId.DB)
+        return db.execute(self.query, self.params)

persona_dsl/ops/kafka/__init__.py

@@ -0,0 +1,4 @@
+from .send_message import SendMessage
+from .message_in_topic import MessageInTopic
+
+__all__ = ["SendMessage", "MessageInTopic"]

persona_dsl/ops/kafka/message_in_topic.py

@@ -0,0 +1,89 @@
+from typing import Optional, Dict, Any, List
+import json
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.skills.use_kafka import UseKafka
+
+
+class MessageInTopic(Ops):
+    """
+    Факт: получить сообщение из Kafka-топика.
+    Опционально фильтрует по ключу и простому подмножеству полей JSON-пейлоада.
+    Возвращает словарь:
+      { topic, partition, offset, timestamp, key, value_raw, value_json, headers }.
+    """
+
+    def __init__(
+        self,
+        topic: str,
+        key: Optional[str] = None,
+        filter: Optional[Dict[str, Any]] = None,
+        max_messages: int = 10,
+        timeout: Optional[float] = None,
+    ):
+        self.topic = topic
+        self.key = key
+        self.filter = filter
+        self.max_messages = max_messages
+        self.timeout = timeout
+
+    def _get_step_description(self, persona: Any) -> str:
+        base = f"{persona} читает сообщения из Kafka топика '{self.topic}'"
+        if self.key:
+            base += f" с ключом '{self.key}'"
+        return base
+
+    def _perform(
+        self, persona: Any, *args: Any, **kwargs: Any
+    ) -> Optional[Dict[str, Any]]:
+        kafka: UseKafka = persona.skill(SkillId.KAFKA)
+        msgs: List[Dict[str, Any]] = kafka.consume(
+            self.topic, max_messages=self.max_messages, timeout=self.timeout
+        )
+
+        def _to_str(b: Any) -> Optional[str]:
+            if b is None:
+                return None
+            if isinstance(b, (bytes, bytearray)):
+                try:
+                    return b.decode("utf-8")
+                except Exception:
+                    return repr(bytes(b))
+            return str(b)
+
+        def _matches_filter(payload_obj: Any) -> bool:
+            if not self.filter:
+                return True
+            if not isinstance(payload_obj, dict):
+                return False
+            for k, v in self.filter.items():
+                if payload_obj.get(k) != v:
+                    return False
+            return True
+
+        for m in msgs:
+            key_str = _to_str(m.get("key"))
+            if self.key is not None and key_str != str(self.key):
+                continue
+            raw_val = m.get("value")
+            text_val = _to_str(raw_val)
+            parsed = None
+            if isinstance(text_val, str):
+                try:
+                    parsed = json.loads(text_val)
+                except Exception:
+                    parsed = None
+            if not _matches_filter(parsed if parsed is not None else text_val):
+                continue
+            return {
+                "topic": m.get("topic"),
+                "partition": m.get("partition"),
+                "offset": m.get("offset"),
+                "timestamp": m.get("timestamp"),
+                "key": key_str,
+                "value_raw": text_val,
+                "value_json": parsed,
+                "headers": m.get("headers") or {},
+            }
+        return None

persona_dsl/ops/kafka/send_message.py

@@ -0,0 +1,35 @@
+from typing import Any, Optional, List
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.skills.use_kafka import UseKafka
+
+
+class SendMessage(Ops):
+    """
+    Низкоуровневая операция: отправляет сообщение в Kafka.
+    """
+
+    def __init__(
+        self,
+        topic: str,
+        value: bytes,
+        key: Optional[bytes] = None,
+        headers: Optional[List[tuple[str, bytes]]] = None,
+    ):
+        self.topic = topic
+        self.value = value
+        self.key = key
+        self.headers = headers
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} отправляет сообщение в Kafka топик '{self.topic}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> None:
+        kafka: UseKafka = persona.skill(SkillId.KAFKA)
+        kafka.send_message(
+            topic=self.topic,
+            message=self.value,
+            key=self.key,
+            headers=self.headers,
+        )

persona_dsl/ops/soap/__init__.py

@@ -0,0 +1,4 @@
+from .call_operation import CallOperation
+from .operation_result import OperationResult
+
+__all__ = ["CallOperation", "OperationResult"]

persona_dsl/ops/soap/call_operation.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.skills.use_soap import UseSOAP
+
+
+class CallOperation(Ops):
+    """
+    Низкоуровневая операция: вызывает SOAP-операцию без возврата результата.
+    """
+
+    def __init__(self, service: str, operation: str, *args: Any, **kwargs: Any):
+        self.service = service
+        self.operation = operation
+        self.args = args
+        self.kwargs = kwargs
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} вызывает SOAP операцию '{self.operation}' сервиса '{self.service}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> None:
+        soap: UseSOAP = persona.skill(SkillId.SOAP)
+        soap.call(self.service, self.operation, *self.args, **self.kwargs)

persona_dsl/ops/soap/operation_result.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.skills.use_soap import UseSOAP
+
+
+class OperationResult(Ops):
+    """
+    Низкоуровневая операция: вызывает SOAP-операцию и возвращает результат.
+    """
+
+    def __init__(self, service: str, operation: str, *args: Any, **kwargs: Any):
+        self.service = service
+        self.operation = operation
+        self.args = args
+        self.kwargs = kwargs
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} получает результат SOAP операции '{self.operation}' сервиса '{self.service}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> Any:
+        soap: UseSOAP = persona.skill(SkillId.SOAP)
+        return soap.call(self.service, self.operation, *self.args, **self.kwargs)

persona_dsl/ops/web/__init__.py

@@ -0,0 +1,37 @@
+from .click import Click
+from .fill import Fill
+from .navigate import NavigateTo
+from .press_key import PressKey
+from .current_path import CurrentPath
+from .screenshot import PageScreenshot, ElementScreenshot
+from .aria_snapshot import PageAriaSnapshot, ElementAriaSnapshot
+from .rich_aria_snapshot import RichAriaSnapshot
+from .element_text import ElementText
+from .element_is_visible import ElementIsVisible
+from .generate_page_object import GeneratePageObject
+from .wait_for_navigation import WaitForNavigation
+from .element_attribute import ElementAttribute
+from .input_value import InputValue
+from .elements_count import ElementsCount
+from .table_data import TableData
+
+__all__ = [
+    "Click",
+    "Fill",
+    "NavigateTo",
+    "PressKey",
+    "CurrentPath",
+    "PageScreenshot",
+    "ElementScreenshot",
+    "PageAriaSnapshot",
+    "ElementAriaSnapshot",
+    "RichAriaSnapshot",
+    "ElementText",
+    "ElementIsVisible",
+    "GeneratePageObject",
+    "WaitForNavigation",
+    "ElementAttribute",
+    "InputValue",
+    "ElementsCount",
+    "TableData",
+]

persona_dsl/ops/web/aria_snapshot.py

@@ -0,0 +1,87 @@
+from typing import Any
+
+import allure
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.pages.elements import Element
+
+
+class PageAriaSnapshot(Ops):
+    """
+    Факт: получить ARIA-снепшот всей страницы (page.locator("body").aria_snapshot()).
+    Возвращает YAML-строку с ролями/именами/состояниями.
+    """
+
+    def __init__(self, timeout: float | None = None):
+        """
+        Args:
+            timeout: Необязательный таймаут Playwright-операции.
+        """
+        self.timeout = timeout
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} получает ARIA-снепшот страницы"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> Any:
+        page = persona.skill(SkillId.BROWSER).page
+        if not hasattr(page.locator("body"), "aria_snapshot"):
+            raise RuntimeError(
+                "Эта версия Playwright не поддерживает Locator.aria_snapshot(). Обновите до 1.55+."
+            )
+        snapshot = page.locator("body").aria_snapshot(timeout=self.timeout)
+        try:
+            allure.attach(
+                snapshot,
+                name="aria-page",
+                attachment_type=allure.attachment_type.TEXT,
+            )
+        except Exception:
+            pass
+        return snapshot
+
+
+class ElementAriaSnapshot(Ops):
+    """
+    Факт: получить ARIA-снепшот элемента.
+    Возвращает YAML-строку.
+    """
+
+    def __init__(
+        self,
+        element: Element,
+        timeout: float | None = None,
+    ):
+        """
+        Args:
+            element: Экземпляр элемента страницы.
+            timeout: Необязательный таймаут Playwright-операции.
+        """
+        self.element = element
+        self.timeout = timeout
+
+    def _get_step_description(self, persona: Any) -> str:
+        target = f"элемента '{self.element.name}'"
+        return f"{persona} получает ARIA-снепшот {target}"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> Any:
+        page = persona.skill(SkillId.BROWSER).page
+
+        locator = self.element.resolve(page)
+
+        if not hasattr(locator, "aria_snapshot"):
+            raise RuntimeError(
+                "Эта версия Playwright не поддерживает Locator.aria_snapshot(). Обновите до 1.55+."
+            )
+
+        snapshot = locator.aria_snapshot(timeout=self.timeout)
+        attach_name = f"aria-element:{self.element.name}"
+
+        try:
+            allure.attach(
+                snapshot,
+                name=attach_name,
+                attachment_type=allure.attachment_type.TEXT,
+            )
+        except Exception:
+            pass
+        return snapshot

persona_dsl/ops/web/click.py

@@ -0,0 +1,30 @@
+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 Click(Ops):
+    """
+    Атомарное действие: кликнуть по элементу.
+    Приоритет поиска: по ARIA-роли и имени, затем по `locator`.
+    Поддерживает проброс аргументов в Playwright (force, timeout, etc).
+    """
+
+    def __init__(self, element: Element, **kwargs: Any):
+        if not isinstance(element, Element):
+            raise TypeError(
+                f"Click ожидает экземпляр Element, получено: {type(element)}"
+            )
+        self.element = element
+        self.kwargs = kwargs
+
+    def _get_step_description(self, persona: Any) -> str:
+        extra = f" с параметрами {self.kwargs}" if self.kwargs else ""
+        return f"{persona} кликает по элементу '{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.click(**self.kwargs)

persona_dsl/ops/web/current_path.py

@@ -0,0 +1,17 @@
+from typing import Any
+from urllib.parse import urlparse
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+
+
+class CurrentPath(Ops):
+    """Бизнес-факт: текущий path активной страницы браузера."""
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} запрашивает текущий путь страницы"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> str:
+        """Возвращает текущий путь URL."""
+        full_url = persona.skill(SkillId.BROWSER).page.url
+        return urlparse(full_url).path

persona_dsl/ops/web/element_attribute.py

@@ -0,0 +1,24 @@
+from typing import Any, Optional
+
+from persona_dsl.components.ops import Ops
+from persona_dsl.skills.core.skill_definition import SkillId
+from persona_dsl.pages.elements import Element
+
+
+class ElementAttribute(Ops):
+    """
+    Бизнес-операция: получить значение HTML-атрибута у элемента.
+    Пример: href для ссылок, src для изображений, data-* и т.д.
+    """
+
+    def __init__(self, element: Element, attribute_name: str):
+        self.element = element
+        self.attribute_name = attribute_name
+
+    def _get_step_description(self, persona: Any) -> str:
+        return f"{persona} запрашивает атрибут '{self.attribute_name}' у элемента '{self.element.name}'"
+
+    def _perform(self, persona: Any, *args: Any, **kwargs: Any) -> Optional[str]:
+        page = persona.skill(SkillId.BROWSER).page
+        locator = self.element.resolve(page)
+        return locator.get_attribute(self.attribute_name)