persona-dsl 26.1.20.8__py3-none-any.whl

persona_dsl/pages/page.py

@@ -0,0 +1,44 @@
+from typing import Optional, Dict
+
+from .elements import Element
+
+
+class Page(Element):
+    """
+    Представляет страницу как корневой контейнер для элементов.
+    """
+
+    # LCL-39: Default query params
+    default_query_params: Dict[str, str] = {}
+    expected_path: Optional[str] = None
+
+    def __init__(self, **url_params: str) -> None:
+        super().__init__(name="page", role="document", accessible_name="page")
+        self._url_params = url_params
+
+    def build_url(self, base_url: str | None = None) -> str:
+        """
+        Собирает полный URL: expected_path + query.
+        """
+        if not self.expected_path:
+            raise ValueError(f"Page {self.__class__.__name__} не имеет expected_path.")
+
+        from urllib.parse import urlencode, urljoin
+
+        # Merge params: default < explicit
+        params = self.default_query_params.copy()
+        params.update(self._url_params)
+
+        path = self.expected_path
+        if params:
+            query = urlencode(params)
+            path = f"{path}?{query}"
+
+        if base_url:
+            return urljoin(base_url, path)
+
+        return path
+
+    def __repr__(self) -> str:
+        elements_list = list(self._elements.keys()) if self._elements else []
+        return f"<Page elements={elements_list}>"

persona_dsl/pages/virtual_page.py

@@ -0,0 +1,94 @@
+from typing import Any, Dict
+
+from persona_dsl.pages.elements import Element
+
+# NOTE: PageGenerator is only needed for type checking to avoid circular imports
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+
+class VirtualPage:
+    """
+    Динамическая страница, построенная на основе ARIA-снепшота (dict) в памяти.
+    Позволяет обращаться к элементам по структуре (page.banner.button) без генерации файла.
+    """
+
+    def __init__(self, snapshot: Dict[str, Any]):
+        from persona_dsl.generators.page_generator import PageGenerator
+
+        self._snapshot = snapshot
+        # Используем генератор для получения маппинга ролей на классы,
+        # но логику построения реализуем упрощенно для runtime-объектов
+        self._generator = PageGenerator()
+        self._root = self._build_tree(snapshot)
+
+    @property
+    def root(self) -> Element:
+        return self._root
+
+    def _sanitize_name(self, name: str) -> str:
+        return self._generator._sanitize_name(name)
+
+    def _build_tree(self, node: Dict[str, Any]) -> Element:
+        role = node.get("role", "generic")
+        name = node.get("name", "")
+        ref = node.get("ref")
+
+        # Определяем класс элемента
+        cls = self._generator._ROLE_TO_CLASS.get(role, Element)
+
+        # Создаем инстанс
+        # Мы не знаем точное имя переменной здесь, так как оно зависит от контекста родителя.
+        # Используем роль/имя как временное имя.
+        base_name = self._sanitize_name(name) or role
+
+        kwargs: Dict[str, Any] = {
+            "name": base_name,
+            "accessible_name": name,
+            "aria_ref": ref,
+        }
+        # Если это базовый класс Element, ему нужно передать role явно.
+        # Если это подкласс (Button, Link и т.д.), у них role обычно init=False и задан дефолтом.
+        if cls is Element:
+            kwargs["role"] = role
+
+        el = cls(**kwargs)
+
+        # Обрабатываем детей
+        children = node.get("children", [])
+
+        # Для именования детей нужно следить за уникальностью в рамках этого родителя
+        used_names = set()
+
+        for child_node in children:
+            child_el = self._build_tree(child_node)
+
+            # Придумываем имя для ребенка
+            child_role = child_node.get("role", "element")
+            child_aria_name = child_node.get("name", "")
+
+            var_name_base = self._sanitize_name(child_aria_name) or child_role
+
+            # Уникализация
+            final_name = var_name_base
+            i = 1
+            while final_name in used_names or hasattr(el, final_name):
+                final_name = f"{var_name_base}_{i}"
+                i += 1
+
+            used_names.add(final_name)
+
+            # Обновляем имя элемента
+            child_el.name = final_name
+
+            # Добавляем в родителя
+            # Используем add_element, чтобы прописались parent ссылки и _elements
+            el.add_element(child_el, alias=final_name)
+
+        return el
+
+    def __getattr__(self, name: str) -> Element:
+        # Делегируем доступ к корневому элементу
+        return getattr(self._root, name)

persona_dsl/persona.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+from enum import Enum
+
+
+# from .skills.core.skill_definition import SkillId  # Removed for lazy loading
+from .utils.path import extract_by_path
+
+
+class BaseRole(str, Enum):
+    """Базовый класс для Enum'а с ролями, специфичными для проекта."""
+
+    pass
+
+
+class Persona:
+    def __init__(self, name: str = "Персона"):
+        self.name = name
+        self.skills: Dict[str, Dict[str, Any]] = {}
+        self.memory: Dict[str, Any] = {}
+        self._skill_provider: Optional[Callable[["Persona", Any, str], Any]] = None
+        self.role_id: str = "default"
+        self.params: Dict[str, Any] = {}
+        self.secrets: Dict[str, Any] = {}
+        self.retries_config: Dict[str, Any] = {}
+
+    def __str__(self) -> str:
+        return self.name
+
+    @classmethod
+    def who_can(cls, *skills: Any) -> "Persona":
+        persona = cls()
+        persona.learn(*skills)
+        return persona
+
+    def learn(self, *skills_to_learn: Any) -> "Persona":
+        """Наделяет Персону одним или несколькими навыками."""
+        for skill_type, name, skill_instance in skills_to_learn:
+            if skill_type not in self.skills:
+                self.skills[skill_type] = {}
+            self.skills[skill_type][name] = skill_instance
+        return self
+
+    def make(self, *goals: Any) -> "Persona":
+        if not goals:
+            raise ValueError("Persona.make requires at least one goal.")
+        for goal in goals:
+            goal.make(self)
+        return self
+
+    def set_skill_provider(
+        self, provider: Callable[["Persona", Any, str], Any]
+    ) -> None:
+        """Регистрирует фабрику для ленивого создания навыков."""
+        self._skill_provider = provider
+
+    def param(self, path: str) -> Any:
+        """Извлекает параметр роли по dot/bracket-пути."""
+        return extract_by_path(self.params, path, allow_attr=False)
+
+    def secret(self, path: str) -> Any:
+        """Извлекает секрет роли по dot/bracket-пути."""
+        return extract_by_path(self.secrets, path, allow_attr=False)
+
+    def ctx(self, path: str) -> Any:
+        """
+        Универсальный метод для извлечения данных из контекста персоны (params, secrets, memory).
+        Приоритет: params -> secrets -> memory.
+        """
+        # Попробуем извлечь из params
+        try:
+            return extract_by_path(self.params, path, allow_attr=False)
+        except (KeyError, IndexError, TypeError):
+            pass
+
+        # Попробуем извлечь из secrets
+        try:
+            return extract_by_path(self.secrets, path, allow_attr=False)
+        except (KeyError, IndexError, TypeError):
+            pass
+
+        # Если нигде не нашли, извлекаем из memory (с жёсткой ошибкой, если там тоже нет)
+        try:
+            return extract_by_path(self.memory, path, allow_attr=False)
+        except (KeyError, IndexError, TypeError) as e:
+            raise KeyError(
+                f"Путь '{path}' не найден в контексте персоны (params, secrets, memory)"
+            ) from e
+
+    def skill(self, skill_type: Any, name: str = "default") -> Any:
+        """
+        Возвращает экземпляр навыка по его типу и, опционально, имени.
+        Если навык не был изучен ранее, пытается создать его с помощью skill_provider (если он есть).
+
+        Args:
+            skill_type: Тип навыка (член SkillId).
+            name: Имя навыка. Если не указано, используется 'default'.
+        """
+        # skill_type might be SkillId enum or a string-like object
+        skill_type_str = getattr(skill_type, "value", str(skill_type))
+        skill_name_str = name
+
+        # 1. Проверяем, изучен ли уже навык
+        if (
+            skill_type_str in self.skills
+            and skill_name_str in self.skills[skill_type_str]
+        ):
+            return self.skills[skill_type_str][skill_name_str]
+
+        # 2. Если нет — пытаемся создать через провайдер
+        if self._skill_provider:
+            skill_instance = self._skill_provider(self, skill_type, name)
+            self.learn((skill_type_str, name, skill_instance))
+            return skill_instance
+
+        # 3. Если провайдера нет или он не смог — стандартная ошибка
+        if skill_type_str not in self.skills:
+            raise NameError(
+                f"У Персоны нет навыков типа '{skill_type_str}'. Доступные типы: {list(self.skills.keys())}"
+            )
+
+        raise NameError(
+            f"У Персоны нет навыка '{skill_name_str}' для типа '{skill_type_str}'. Доступные: {list(self.skills[skill_type_str].keys())}"
+        )