persona-dsl 26.1.20.8__py3-none-any.whl

persona_dsl/skills/use_soap.py

@@ -0,0 +1,66 @@
+from typing import Any
+
+from zeep import Client
+
+from .core.base import Skill
+
+
+class UseSOAP(Skill):
+    """Навык для взаимодействия с SOAP API."""
+
+    def __init__(self, wsdl_url: str):
+        super().__init__(driver=None)
+        self.wsdl_url = wsdl_url
+
+    @staticmethod
+    def at(wsdl_url: str) -> "UseSOAP":
+        """Фабричный метод для создания экземпляра навыка.
+
+        Args:
+            wsdl_url: URL к WSDL-файлу сервиса.
+
+        Returns:
+            Экземпляр UseSOAP.
+        """
+        return UseSOAP(wsdl_url)
+
+    def _get_client(self) -> Client:
+        if self.driver is None:
+            self.driver = Client(self.wsdl_url)
+        return self.driver
+
+    def call(self, service: str, operation: str, *args: Any, **kwargs: Any) -> Any:
+        """Вызывает операцию SOAP-сервиса."""
+        client = self._get_client()
+
+        if service not in client.wsdl.services:
+            raise ValueError(
+                f"Сервис '{service}' не найден в WSDL. Доступные: {list(client.wsdl.services.keys())}"
+            )
+
+        # Bind to the service, letting zeep choose the first available port.
+        bound_service = client.bind(service, None)
+
+        try:
+            op = getattr(bound_service, operation)
+            return op(*args, **kwargs)
+        except AttributeError as e:
+            raise ValueError(
+                f"Операция '{operation}' не найдена в сервисе '{service}'."
+            ) from e
+
+    def release(self) -> None:
+        """Освобождает ресурсы SOAP-клиента (если они есть)."""
+        if self.driver:
+            try:
+                # Если driver — это клиент zeep, попробуем закрыть его HTTP-сессию
+                transport = getattr(self.driver, "transport", None)
+                session = getattr(transport, "session", None) if transport else None
+                if session and hasattr(session, "close"):
+                    session.close()
+            except Exception:
+                pass
+
+    def forget(self) -> None:
+        """Совместимость: делегирует в базовый Skill.forget()."""
+        return super().forget()

persona_dsl/utils/artifacts.py

@@ -0,0 +1,22 @@
+import os
+import re
+from pathlib import Path
+
+
+def sanitize_filename(name: str) -> str:
+    """Безопасное имя файла для снапшотов/скриншотов."""
+    return re.sub(r"[^A-Za-z0-9._-]+", "-", str(name)).strip("-") or "snapshot"
+
+
+def artifacts_dir(subdir: str) -> Path:
+    """Каталог для артефактов запуска: <ARTIFACTS>/<run_id>/<subdir> или локальный ./<subdir>."""
+    base_dir = Path(os.getenv("TAAS_ARTIFACTS_DIR", str(Path.cwd())))
+    run_id = os.getenv("TAAS_RUN_ID")
+    out = (base_dir / run_id / subdir) if run_id else (base_dir / subdir)
+    out.mkdir(parents=True, exist_ok=True)
+    return out
+
+
+def screenshots_dir() -> Path:
+    """Каталог для скриншотов."""
+    return artifacts_dir("screenshots")

persona_dsl/utils/config.py

@@ -0,0 +1,54 @@
+import yaml
+from dataclasses import dataclass, field
+from pathlib import Path
+from dotenv import load_dotenv
+from typing import Dict, Any, Optional
+
+
+@dataclass
+class Config:
+    """Хранит структурированную конфигурацию для тестового окружения."""
+
+    skills: Dict[str, Any] = field(default_factory=dict)
+    personas: Dict[str, Any] = field(default_factory=dict)
+    auth: Dict[str, Any] = field(default_factory=dict)
+    reporting: Dict[str, Any] = field(default_factory=dict)
+    retries: Dict[str, Any] = field(default_factory=dict)
+    env: str = "dev"
+
+    @staticmethod
+    def load(env: str, project_root: Optional[Path] = None) -> "Config":
+        """
+        Загружает конфигурацию для указанного окружения.
+        1. Читает `config/{env}.yaml`.
+        2. Читает `config/auth.yaml` (если существует).
+        3. Загружает переменные из `.env.{env}`.
+        """
+        root = project_root or Path.cwd()
+        config_path = root / "config" / f"{env}.yaml"
+        if not config_path.exists():
+            raise FileNotFoundError(
+                f"Конфигурация для окружения '{env}' не найдена: {config_path}"
+            )
+
+        with open(config_path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+
+        auth_data: Dict[str, Any] = {}
+        auth_path = root / "config" / "auth.yaml"
+        if auth_path.exists():
+            with open(auth_path, "r", encoding="utf-8") as f:
+                auth_data = yaml.safe_load(f) or {}
+
+        dotenv_path = root / f".env.{env}"
+        if dotenv_path.exists():
+            load_dotenv(dotenv_path)
+
+        return Config(
+            skills=data.get("skills", {}),
+            personas=data.get("personas", {}),
+            auth=auth_data,
+            reporting=data.get("reporting", {}),
+            retries=data.get("retries", {}),
+            env=env,
+        )

persona_dsl/utils/data_providers.py

@@ -0,0 +1,159 @@
+import os
+import uuid as _uuid
+import random as _random
+import datetime as _dt
+from zoneinfo import ZoneInfo
+from typing import Any, List, Union, Optional
+from faker import Faker
+
+
+def _seed() -> int:
+    """
+    Детерминированный seed на основе TAAS_RUN_ID, TAAS_ENV и TAAS_VARIANT_ID (если есть) или фиксированный.
+    """
+    run_id = os.getenv("TAAS_RUN_ID")
+    if not run_id:
+        return 42
+    env = os.getenv("TAAS_ENV") or ""
+    variant = os.getenv("TAAS_VARIANT_ID") or ""
+    # Простая хеш-функция по строке "{run_id}:{env}:{variant}"
+    acc = 0
+    for ch in f"{run_id}:{env}:{variant}":
+        acc = (acc * 31 + ord(ch)) % 2_147_483_647
+    return acc
+
+
+# Кеши, индексированные по seed'у для обеспечения детерминированности для каждой вариации теста.
+_RNG_PER_SEED: dict[int, _random.Random] = {}
+_FAKER_CACHE_PER_SEED: dict[int, dict[str, Faker]] = {}
+_SEQUENCES_PER_SEED: dict[int, dict[str, int]] = {}
+
+
+def _get_rng() -> _random.Random:
+    """Возвращает детерминированный экземпляр RNG, привязанный к текущему seed'у."""
+    seed = _seed()
+    if seed not in _RNG_PER_SEED:
+        _RNG_PER_SEED[seed] = _random.Random(seed)
+    return _RNG_PER_SEED[seed]
+
+
+def _seed_with(*parts: str) -> int:
+    acc = _seed()
+    for part in parts:
+        for ch in str(part):
+            acc = (acc * 31 + ord(ch)) % 2_147_483_647
+    return acc
+
+
+def _get_faker(locale: str) -> Faker:
+    seed = _seed()
+    if seed not in _FAKER_CACHE_PER_SEED:
+        _FAKER_CACHE_PER_SEED[seed] = {}
+
+    f = _FAKER_CACHE_PER_SEED[seed].get(locale)
+    if not f:
+        f = Faker(locale)
+        faker_seed = _seed_with("faker", locale)
+        f.seed_instance(faker_seed)
+        _FAKER_CACHE_PER_SEED[seed][locale] = f
+    return f
+
+
+def uuid() -> str:
+    """UUID v4 как строка. Детерминированный относительно seed, но соответствующий RFC 4122 (версия/вариант)."""
+    # Генерируем 16 детерминированных байт из RNG и выставляем биты версии/варианта
+    rng = _get_rng()
+    b = bytearray(rng.getrandbits(8) for _ in range(16))
+    b[6] = (b[6] & 0x0F) | 0x40  # версия 4
+    b[8] = (b[8] & 0x3F) | 0x80  # вариант RFC 4122 (10xxxxxx)
+    return str(_uuid.UUID(bytes=bytes(b)))
+
+
+def randomInt(min: int, max: int) -> int:
+    return _get_rng().randint(int(min), int(max))
+
+
+def randomFloat(min: float, max: float, precision: int = 2) -> float:
+    value = _get_rng().uniform(float(min), float(max))
+    return round(value, int(precision))
+
+
+_ALPHANUM = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+
+
+def randomString(length: int, alphabet: str = _ALPHANUM) -> str:
+    length = int(length)
+    return "".join(_get_rng().choice(alphabet) for _ in range(length))
+
+
+def now(
+    fmt: Optional[str] = None, tz: Optional[str] = None
+) -> Union[str, _dt.datetime]:
+    zone = ZoneInfo(tz) if tz else None
+    dt = _dt.datetime.now(tz=zone)
+    return dt.strftime(fmt) if fmt else dt
+
+
+def dateShift(
+    days: int, fmt: Optional[str] = None, tz: Optional[str] = None
+) -> Union[str, _dt.datetime]:
+    zone = ZoneInfo(tz) if tz else None
+    dt = _dt.datetime.now(tz=zone) + _dt.timedelta(days=int(days))
+    return dt.strftime(fmt) if fmt else dt
+
+
+def fromEnv(name: str, default: Any = None) -> Any:
+    return os.getenv(str(name), default)
+
+
+def concat(parts: List[Any]) -> str:
+    def _to_str(v: Any) -> str:
+        return str(v)
+
+    return "".join(_to_str(p) for p in parts)
+
+
+def faker(
+    provider: str,
+    locale: str = "ru_RU",
+    args: List[Any] | None = None,
+    kwargs: dict | None = None,
+) -> Any:
+    """
+    Вызов провайдера Faker по имени с детерминированным seed на основе TAAS_RUN_ID и локали.
+    Пример: faker("first_name", locale="ru_RU")
+    """
+    f = _get_faker(locale)
+    func = getattr(f, provider)
+    return func(*(args or []), **(kwargs or {}))
+
+
+def sequence(name: str, seed: int | None = None) -> int:
+    """
+    Детерминированная последовательность по имени. Первое значение фиксировано для данного run_id и name.
+    """
+    main_seed = _seed()
+    if main_seed not in _SEQUENCES_PER_SEED:
+        _SEQUENCES_PER_SEED[main_seed] = {}
+
+    sequences_for_seed = _SEQUENCES_PER_SEED[main_seed]
+    if name not in sequences_for_seed:
+        start = seed if seed is not None else _seed_with("sequence", name)
+        sequences_for_seed[name] = int(start % 1_000_000)
+    current = sequences_for_seed[name]
+    sequences_for_seed[name] += 1
+    return current
+
+
+def template(pattern: str, variables: dict) -> str:
+    """
+    Простой шаблонизатор строк на основе str.format.
+    Любая ошибка форматирования — явная ошибка без фолбеков.
+    """
+    safe_vars = {k: str(v) for k, v in (variables or {}).items()}
+    try:
+        return pattern.format_map(safe_vars)
+    except Exception as e:
+        raise ValueError(
+            f"data_providers.template: ошибка форматирования шаблона {pattern!r} с переменными {safe_vars}: {e}"
+        ) from e

persona_dsl/utils/decorators.py

@@ -0,0 +1,80 @@
+import pytest
+from typing import Any, Optional, Sequence, Callable, TypeVar
+
+T = TypeVar("T", bound=Callable[..., Any])
+
+
+def tag(*tags: str) -> Callable[[T], T]:
+    """Декоратор для добавления тегов (маркеров pytest) к тестам."""
+
+    def wrapper(func: T) -> T:
+        marked_func = func
+        for t in tags:
+            marked_func = getattr(pytest.mark, t)(marked_func)
+        return marked_func
+
+    return wrapper
+
+
+def data_driven(
+    source: Optional[Any] = None,
+    file: bool = False,
+    name_template: Optional[str] = None,
+    only: Optional[Sequence[str]] = None,
+) -> Callable[[T], T]:
+    """
+    Декоратор для параметризации тестов, управляемый фреймворком.
+
+    Args:
+        source: Источник данных.
+                Если file=True, это имя файла (без .yaml) в директории `tests/data`.
+                Если file=False, это список словарей с тестовыми данными.
+        file: Указывает, как интерпретировать `source`.
+        name_template: Необязательный шаблон имени вариации (ids) для pytest, например "{test_id}-{input}".
+        only: Необязательный список test_id вариаций, которые нужно включить.
+    """
+
+    def wrapper(func: T) -> T:
+        return pytest.mark.data_driven(
+            source=source, file=file, name_template=name_template, only=only
+        )(func)
+
+    return wrapper
+
+
+def parametrize_simple(
+    arg_name: str,
+    values: Sequence[Any],
+    ids: Optional[Sequence[str]] = None,
+    name_template: Optional[str] = None,
+) -> Callable[[T], T]:
+    """
+    Упрощённая альтернатива для простых скалярных наборов: обёртка над pytest.mark.parametrize.
+
+    Args:
+        arg_name: Имя параметра тестовой функции.
+        values: Последовательность значений (скаляры или словари).
+        ids: Необязательный список id для параметров.
+        name_template: Необязательный шаблон формата для id (например, "val-{value}").
+                       Если значение — словарь, шаблон форматируется через **value;
+                       иначе доступен плейсхолдер {value}.
+    """
+    computed_ids = None
+    if ids is not None:
+        computed_ids = list(ids)
+    elif isinstance(name_template, str) and name_template:
+
+        def _fmt(v: Any) -> str:
+            try:
+                if isinstance(v, dict):
+                    return name_template.format(**v)
+                return name_template.format(value=v)
+            except Exception:
+                return str(v)
+
+        computed_ids = [_fmt(v) for v in values]
+
+    def wrapper(func: T) -> T:
+        return pytest.mark.parametrize(arg_name, list(values), ids=computed_ids)(func)
+
+    return wrapper

persona_dsl/utils/metrics.py

@@ -0,0 +1,69 @@
+import time
+import os
+import logging
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+class Reporter(ABC):
+    @abstractmethod
+    def report(self, metric_name: str, value: float, tags: Dict[str, Any]) -> None:
+        pass  # pragma: no cover
+
+
+class FileReporter(Reporter):
+    def __init__(self, output_file: Path):
+        self._output_file = output_file
+
+    def report(self, metric_name: str, value: float, tags: Dict[str, Any]) -> None:
+        tag_str = ",".join([f"{k}={v}" for k, v in tags.items()])
+        with open(self._output_file, "a", encoding="utf-8") as f:
+            f.write(f"{metric_name}{{{tag_str}}} {value} {int(time.time())}\n")
+
+
+logger = logging.getLogger(__name__)
+
+
+class StdoutReporter(Reporter):
+    def report(self, metric_name: str, value: float, tags: Dict[str, Any]) -> None:
+        tag_str = ",".join([f"{k}={v}" for k, v in tags.items()])
+        logger.info(f"{metric_name}{{{tag_str}}} {value} {int(time.time())}")
+
+
+class Counter:
+    def __init__(self, metrics_system: "Metrics", name: str, tags: Dict[str, Any]):
+        self._metrics = metrics_system
+        self._name = name
+        self._tags = tags
+
+    def inc(self, value: int = 1) -> None:
+        self._metrics.report(f"{self._name}.count", value, self._tags)
+
+
+class Metrics:
+    def __init__(self) -> None:
+        self._reporters: List[Reporter] = []
+
+    def add_reporter(self, reporter: Reporter) -> None:
+        self._reporters.append(reporter)
+
+    def report(self, metric_name: str, value: float, tags: Dict[str, Any]) -> None:
+        for reporter in self._reporters:
+            reporter.report(metric_name, value, tags)
+
+    def gauge(
+        self, name: str, value: float, tags: Optional[Dict[str, Any]] = None
+    ) -> None:
+        self.report(name, value, tags or {})
+
+    def counter(self, name: str, tags: Optional[Dict[str, Any]] = None) -> "Counter":
+        return Counter(self, name, tags or {})
+
+
+# Глобальный экземпляр для использования в рамках сессии
+metrics = Metrics()
+log_path = os.getenv("TEST_METRICS_FILE", "test_metrics.log")
+metrics.add_reporter(FileReporter(Path(log_path)))
+if os.getenv("TEST_METRICS_STDOUT", "0") == "1":
+    metrics.add_reporter(StdoutReporter())

persona_dsl/utils/naming.py

@@ -0,0 +1,14 @@
+import re
+
+
+def to_pascal_case(s: str) -> str:
+    """Преобразует snake_case или kebab-case (и пути) в PascalCase."""
+    parts = re.split(r"[^a-zA-Z0-9]+", s)
+    return "".join(p.capitalize() for p in parts if p)
+
+
+def to_snake_case(name: str) -> str:
+    """Преобразует PascalCase или kebab-case в snake_case."""
+    name = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", name)
+    name = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+    return name.replace("-", "_").lower()

persona_dsl/utils/path.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+from typing import Any, List, Union
+
+
+class PathSyntaxError(ValueError):
+    """Синтаксическая ошибка пути dot/bracket."""
+
+
+Token = Union[str, int]
+
+
+def _tokenize(path: str) -> List[Token]:
+    """
+    Разбивает строку пути на токены:
+    - dot:  a.b.c        -> ["a","b","c"]
+    - bracket index: [0] -> [0]
+    - bracket key:  ["x.y"] или ['z[0]'] -> ["x.y"], ["z[0]"]
+    Поддерживает экранирование в кавычках: \" и \'
+    """
+    if not isinstance(path, str):
+        raise PathSyntaxError("Путь должен быть строкой")
+    if not path:
+        return []
+    tokens: List[Token] = []
+    buf = ""
+    i = 0
+    n = len(path)
+
+    def _flush_buf() -> None:
+        nonlocal buf
+        if buf:
+            tokens.append(buf)
+            buf = ""
+
+    while i < n:
+        c = path[i]
+        if c == ".":
+            _flush_buf()
+            i += 1
+            continue
+        if c == "[":
+            _flush_buf()
+            i += 1
+            if i >= n:
+                raise PathSyntaxError(f"Ожидалось содержимое после '[' в позиции {i-1}")
+            # Ключ в кавычках
+            if path[i] in ("'", '"'):
+                quote = path[i]
+                i += 1
+                s = ""
+                while i < n:
+                    ch = path[i]
+                    if ch == "\\" and i + 1 < n:
+                        s += path[i + 1]
+                        i += 2
+                        continue
+                    if ch == quote:
+                        break
+                    s += ch
+                    i += 1
+                if i >= n or path[i] != quote:
+                    raise PathSyntaxError(f"Незакрытая кавычка {quote} в позиции {i}")
+                i += 1
+                if i >= n or path[i] != "]":
+                    raise PathSyntaxError(
+                        f"Ожидалась закрывающая ']' после ключа в кавычках (позиция {i})"
+                    )
+                i += 1
+                tokens.append(s)
+                continue
+            # Индекс списка
+            j = i
+            if j < n and path[j] == "-":
+                j += 1
+            start_digits = j
+            while j < n and path[j].isdigit():
+                j += 1
+            if j == start_digits:
+                raise PathSyntaxError(
+                    f"Ожидался числовой индекс после '[' (позиция {i-1})"
+                )
+            if j >= n or path[j] != "]":
+                raise PathSyntaxError(
+                    f"Ожидалась закрывающая ']' после индекса (позиция {j})"
+                )
+            idx = int(path[i:j])
+            tokens.append(idx)
+            i = j + 1
+            continue
+        # Обычный символ идентификатора
+        if c in ("'", '"'):
+            raise PathSyntaxError(
+                f"Недопустимый символ кавычки в идентификаторе в позиции {i}"
+            )
+        buf += c
+        i += 1
+
+    _flush_buf()
+    return tokens
+
+
+def tokenize_path(path: str) -> List[Token]:
+    """
+    Публичный токенайзер пути. Возвращает список токенов (str|int) по dot/bracket‑нотации.
+    """
+    return _tokenize(path)
+
+
+def extract_by_path(root: Any, path: str, *, allow_attr: bool = True) -> Any:
+    """
+    Достаёт значение из dict/list/объекта по пути вида "a.b[0]['x.y']".
+    Бросает понятные ошибки при несоответствии структуры/индексов/ключей.
+    """
+    tokens = _tokenize(path)
+    cur = root
+    for t in tokens:
+        if isinstance(t, int):
+            if not isinstance(cur, (list, tuple)):
+                raise TypeError(
+                    f"Ожидался список/кортеж для индексации [{t}], получено: {type(cur).__name__}"
+                )
+            try:
+                cur = cur[t]
+            except IndexError:
+                raise IndexError(
+                    f"Индекс вне диапазона: [{t}] при длине {len(cur)}"
+                ) from None
+        else:
+            if isinstance(cur, dict):
+                if t not in cur:
+                    raise KeyError(f"Ключ отсутствует: '{t}'")
+                cur = cur[t]
+            elif allow_attr and hasattr(cur, t):
+                cur = getattr(cur, t)
+            else:
+                raise TypeError(
+                    f"Нельзя обратиться по ключу/атрибуту '{t}' у типа {type(cur).__name__}"
+                )
+    return cur
+
+
+def try_extract_by_path(
+    root: Any, path: str, *, default: Any = None, allow_attr: bool = True
+) -> Any:
+    """
+    Мягкая версия: вместо исключений возвращает default при любой ошибке.
+    """
+    try:
+        return extract_by_path(root, path, allow_attr=allow_attr)
+    except Exception:
+        return default
+
+
+def remove_by_path(obj: Any, path: str, *, strict: bool = False) -> None:
+    """
+    Удаляет значение по пути из dict/list. Если strict=True — бросает понятные ошибки,
+    иначе отсутствующие ветки тихо игнорируются.
+    """
+    tokens = _tokenize(path)
+    if not tokens:
+        if strict:
+            raise PathSyntaxError("Пустой путь для удаления")
+        return
+    cur = obj
+    # идём до родителя
+    try:
+        for t in tokens[:-1]:
+            if isinstance(t, int):
+                if not isinstance(cur, list):
+                    raise TypeError(
+                        f"Ожидался список для индекса [{t}], получено {type(cur).__name__}"
+                    )
+                cur = cur[t]
+            else:
+                if isinstance(cur, dict):
+                    cur = cur[t]
+                else:
+                    raise TypeError(
+                        f"Ожидался dict для ключа '{t}', получено {type(cur).__name__}"
+                    )
+        last = tokens[-1]
+        if isinstance(last, int):
+            if not isinstance(cur, list):
+                raise TypeError(
+                    f"Ожидался список для индекса [{last}], получено {type(cur).__name__}"
+                )
+            del cur[last]
+        else:
+            if not isinstance(cur, dict):
+                raise TypeError(
+                    f"Ожидался dict для ключа '{last}', получено {type(cur).__name__}"
+                )
+            if strict:
+                del cur[last]
+            else:
+                cur.pop(last, None)
+    except Exception:
+        if strict:
+            raise
+        # мягкий режим — игнорируем ошибки
+        return