pyplaykit 0.1.0__py3-none-any.whl

pyplaykit-0.1.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/base_page.py,sha256=90M-QMTblKIU7RHILzR0ZPFRuVStaQ80cS9mzMERJxA,3978
+core/base_test.py,sha256=xz4bD7V1mFkQ6S-ZEOzv9iQGBqrpRk1SWtyD9Jd2qSQ,779
+core/browser_factory.py,sha256=_uuGdY-e4n39QzMOZDwzlp9R_8jopxCByq980tp2CLU,1067
+core/playwright_manager.py,sha256=oFUBouOclpdSmn7Z2daxfbvdSKBz8EU_9Y9076ixKfo,1302
+dist_pkg/__init__.py,sha256=KVhzkLGG8RdxNk9El-8JruA7L4WBljy7f5JtkgrMhHM,197
+dist_pkg/distribution.py,sha256=RZA-XOGQrBpG6nXnIZeDvri_cRTL-Nv7TBZsevyxPqs,1598
+integrations/__init__.py,sha256=82mpeM9c1NLsbMxylOpjdknnpnavDEePql40Bi3lnxY,466
+integrations/adapters.py,sha256=3tlHQu0UD8mTE1iISpXhly4JzQ_BeYfg9xXZxIHsCXI,5449
+orchestration/__init__.py,sha256=omP4kquqZ2lueb2xBN8Bu1F-zHfqYjsqlvPjQgje9hI,156
+orchestration/planner.py,sha256=BPbfkTpnxaGkeqcdU0Vm-byOfNoOWAgfb2X4m7eqpXw,5933
+pages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pages/dashboard_page.py,sha256=2ywYZOV1pcv7GrV9kGdPFmHtq9pE-yNCEycofkZljBE,849
+pages/login_page.py,sha256=KOkRHRDLP5Xj7ClsM1Y1abOlzveoJigpRuXjAJVMXLw,1065
+pages/orangehrm_login_page.py,sha256=h5weajsblILbPKQt6KFYh-vX2BZHAzDSZfj5BhexLic,2849
+pages/saucedemo_inventory_page.py,sha256=ga1MngZPQqAGmA34i8zCRyErFOK-upvoaECh4Zk0GtA,4036
+pages/saucedemo_login_page.py,sha256=X3P_pFfOeMlsRAO53kcQ0G0saVIRzODS_WFIawszL2s,1403
+plugins/__init__.py,sha256=k8WKwbK-5HeQ0Jhgw6fRwRs6OrLym3jHU4iMsSFUaaI,418
+plugins/api_plugin.py,sha256=qOnit0CI1N7BQKrFW4h8v03JUCiBzimw7TmoMdUGwLU,255
+plugins/base.py,sha256=6kkRgGWMBoRaYi5Y7QwBjB72OxxqL5cASmPxED1HsM8,643
+plugins/data_plugin.py,sha256=kihGM5eKblgdzzg7exd0jvNk3RB9YpkhG6P_NIid1NQ,259
+plugins/registry.py,sha256=DoQ-UqRYnACWfn42CshwM6mZG3619HuWC-GCE53v_XE,2783
+plugins/security_plugin.py,sha256=-rxIbVFe2vChLysmdpXN75YiHorb9vrnDuG1bS8LzF4,275
+resilience/__init__.py,sha256=HSIH-phgvPmf_28n0mtEuVmPQT0lHWhjrdDro1LZoM4,222
+resilience/locator_recovery.py,sha256=Dnz0s4hC4YXNEcdv1K-QaP_lEhZ3axTYmUh8-AVl4SI,2920
+utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utils/api_client.py,sha256=1IxoHGYeSkYfzuUiYmdP9RRkKSEDjhEgBG5rX9ARtpM,4826
+utils/assertion_helper.py,sha256=0u2KNlxY4ZFVtuiVgbP57Uv8SjZ-QnxfHklwcnAydyg,837
+utils/data_loader.py,sha256=h0mpoutvnfMnWwb1344VGxK6MmM_ChEWP_yriyehU2s,1147
+utils/data_validator.py,sha256=H4zCvgN3X6SKoyjxIokPPuH7-RjGVcaP3447oVahB0g,17251
+utils/environment_validator.py,sha256=GQ1BZRGKmgK8pbycISwG5kfy5woxpH1WJPBKfiiteH4,3594
+utils/file_reader.py,sha256=lBd9TbGDJJDzJaDY71XFFHoorfB0pr6MCLg4WcS6v3s,1236
+utils/logger.py,sha256=ExRn7PrgdHfUbS4bEao4WHJsNSD4UcvL_LzbIdq3JSk,973
+utils/observability.py,sha256=-n-rsKL3OP-L3fXrQJ1OZLFCck7REuDN8qryyM1fBHM,6860
+utils/response_validator.py,sha256=tIGN_R9jgUsza6XK7QbxuptV_QAdBRr8ewbDOQ-OLcA,2466
+utils/screenshot_helper.py,sha256=C5oucA5Q4xyB1s-8mX65Im2oaoBSG2tiNV_jtRiq2qc,686
+utils/tdm.py,sha256=0BNeKORfIDlLtcFFIJUew2FVEv5MFBkdTSH106ZOZCE,8215
+utils/yaml_config_reader.py,sha256=neiri3N6QgzDtUD7buzHR7dYWo_2MbW0GE1YRpvPBQ8,4123
+pyplaykit-0.1.0.dist-info/METADATA,sha256=C1zl3R8zedpkQSNTyiWvQQFePlRDovCsROqp_AAXXYg,10975
+pyplaykit-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyplaykit-0.1.0.dist-info/top_level.txt,sha256=DROtyBRVqfRJXUjXj3TYe5SfSTmIVKm16b7YhMD6ZI0,72
+pyplaykit-0.1.0.dist-info/RECORD,,

pyplaykit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyplaykit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,8 @@
+core
+dist_pkg
+integrations
+orchestration
+pages
+plugins
+resilience
+utils

resilience/__init__.py

@@ -0,0 +1,5 @@
+"""Resilience utilities for self-healing interaction patterns."""
+
+from .locator_recovery import resolve_visible_locator, write_resilience_audit_event
+
+__all__ = ["resolve_visible_locator", "write_resilience_audit_event"]

resilience/locator_recovery.py

@@ -0,0 +1,72 @@
+"""Locator self-healing helpers with fallback chains and DOM retries."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Callable
+
+
+def resolve_visible_locator(
+    *,
+    locator_getter: Callable[[str], Any],
+    visible_assertion: Callable[[Any], None],
+    primary_selector: str,
+    fallback_selectors: list[str] | None = None,
+    dom_retry_count: int = 0,
+    confidence_decay_per_hop: float = 0.15,
+    confidence_decay_per_retry: float = 0.1,
+) -> tuple[Any, str, int, dict[str, Any]]:
+    """Resolve the first visible locator using optional fallback selectors and retry loops."""
+    candidates = [primary_selector] + [selector for selector in (fallback_selectors or []) if selector]
+    if not candidates:
+        raise ValueError("At least one selector must be provided")
+
+    retries = max(0, int(dom_retry_count))
+    hop_decay = max(0.0, float(confidence_decay_per_hop))
+    retry_decay = max(0.0, float(confidence_decay_per_retry))
+    last_error: Exception | None = None
+    attempted_actions: list[dict[str, Any]] = []
+
+    for attempt in range(retries + 1):
+        for selector_index, selector in enumerate(candidates):
+            locator = locator_getter(selector)
+            try:
+                visible_assertion(locator)
+                confidence = max(0.0, min(1.0, 1.0 - (selector_index * hop_decay) - (attempt * retry_decay)))
+                event = {
+                    "selected_selector": selector,
+                    "attempt": attempt,
+                    "selector_index": selector_index,
+                    "confidence_score": round(confidence, 4),
+                    "used_fallback": selector_index > 0,
+                    "used_retry": attempt > 0,
+                    "attempted_actions": attempted_actions,
+                }
+                return locator, selector, attempt, event
+            except Exception as error:
+                last_error = error
+                attempted_actions.append(
+                    {
+                        "attempt": attempt,
+                        "selector": selector,
+                        "error": str(error),
+                    }
+                )
+
+    details = ", ".join(candidates)
+    raise AssertionError(
+        f"Unable to resolve visible element after {retries + 1} attempt(s) using selectors: {details}"
+    ) from last_error
+
+
+def write_resilience_audit_event(audit_log_path: str, event: dict[str, Any]) -> str:
+    """Append one resilience audit event as JSON line and return the file path."""
+    if not audit_log_path or not str(audit_log_path).strip():
+        raise ValueError("audit_log_path must be a non-empty string")
+
+    output = Path(audit_log_path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with output.open("a", encoding="utf-8") as stream:
+        stream.write(json.dumps(event, sort_keys=True) + "\n")
+    return str(output.resolve())

utils/api_client.py

@@ -0,0 +1,125 @@
+"""Reusable API client built on Python standard library for framework-level API testing."""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode, urljoin
+from urllib.request import Request, urlopen
+
+
+@dataclass
+class ApiResponse:
+    """Normalized API response wrapper for assertions and reporting."""
+
+    status_code: int
+    headers: dict[str, str]
+    text: str
+    elapsed_ms: float
+
+    def json(self) -> Any:
+        """Parse response body as JSON."""
+        return json.loads(self.text) if self.text else {}
+
+
+class ApiClient:
+    """Simple API client supporting retries and JSON payload handling."""
+
+    def __init__(
+        self,
+        base_url: str = "",
+        default_headers: dict[str, str] | None = None,
+        timeout_seconds: int = 30,
+        retries: int = 1,
+        retry_status_codes: set[int] | None = None,
+        logger=None,
+    ) -> None:
+        self.base_url = base_url
+        self.default_headers = default_headers or {}
+        self.timeout_seconds = timeout_seconds
+        self.retries = retries
+        self.retry_status_codes = retry_status_codes or {429, 500, 502, 503, 504}
+        self.logger = logger
+
+    def request(
+        self,
+        method: str,
+        endpoint: str,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        json_body: dict[str, Any] | list[Any] | None = None,
+        data: bytes | None = None,
+    ) -> ApiResponse:
+        """Send an HTTP request and return a normalized response."""
+        url = self._build_url(endpoint, params)
+        merged_headers = {**self.default_headers, **(headers or {})}
+
+        payload = data
+        if json_body is not None:
+            payload = json.dumps(json_body).encode("utf-8")
+            merged_headers.setdefault("Content-Type", "application/json")
+
+        request = Request(url=url, method=method.upper(), headers=merged_headers, data=payload)
+
+        attempt = 0
+        while attempt <= self.retries:
+            attempt += 1
+            start = time.perf_counter()
+            try:
+                if self.logger:
+                    self.logger.info("API request %s %s (attempt %s)", method.upper(), url, attempt)
+                with urlopen(request, timeout=self.timeout_seconds) as response:
+                    elapsed_ms = (time.perf_counter() - start) * 1000
+                    body = response.read().decode("utf-8")
+                    return ApiResponse(
+                        status_code=response.getcode(),
+                        headers={k: v for k, v in response.headers.items()},
+                        text=body,
+                        elapsed_ms=elapsed_ms,
+                    )
+            except HTTPError as error:
+                elapsed_ms = (time.perf_counter() - start) * 1000
+                body = error.read().decode("utf-8") if error.fp else ""
+                response = ApiResponse(
+                    status_code=error.code,
+                    headers={k: v for k, v in error.headers.items()} if error.headers else {},
+                    text=body,
+                    elapsed_ms=elapsed_ms,
+                )
+                if self._should_retry(error.code, attempt):
+                    continue
+                return response
+            except URLError as error:
+                if attempt <= self.retries:
+                    continue
+                raise RuntimeError(f"Request failed after retries for URL '{url}': {error.reason}") from error
+
+        raise RuntimeError(f"Request retries exhausted for URL '{url}'.")
+
+    def get(self, endpoint: str, params: dict[str, Any] | None = None, headers: dict[str, str] | None = None) -> ApiResponse:
+        """Shortcut for GET requests."""
+        return self.request("GET", endpoint, params=params, headers=headers)
+
+    def post(
+        self,
+        endpoint: str,
+        json_body: dict[str, Any] | list[Any] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> ApiResponse:
+        """Shortcut for POST requests with optional JSON body."""
+        return self.request("POST", endpoint, headers=headers, json_body=json_body)
+
+    def _build_url(self, endpoint: str, params: dict[str, Any] | None = None) -> str:
+        base = self.base_url.rstrip("/") + "/" if self.base_url else ""
+        url = urljoin(base, endpoint.lstrip("/")) if base else endpoint
+        if not params:
+            return url
+        query = urlencode(params, doseq=True)
+        separator = "&" if "?" in url else "?"
+        return f"{url}{separator}{query}"
+
+    def _should_retry(self, status_code: int, attempt: int) -> bool:
+        return attempt <= self.retries and status_code in self.retry_status_codes

utils/assertion_helper.py

@@ -0,0 +1,21 @@
+"""Reusable assertion helpers with enterprise-friendly failure messaging."""
+
+
+def assert_equal(actual, expected, message: str = "") -> None:
+    """Assert equality with optional custom message."""
+    if actual != expected:
+        default_message = f"Expected '{expected}', but found '{actual}'."
+        raise AssertionError(message or default_message)
+
+
+def assert_true(condition: bool, message: str) -> None:
+    """Assert condition is true with custom message."""
+    if not condition:
+        raise AssertionError(message)
+
+
+def assert_in(member, container, message: str = "") -> None:
+    """Assert member exists in container with optional custom message."""
+    if member not in container:
+        default_message = f"Expected '{member}' to be present in '{container}'."
+        raise AssertionError(message or default_message)

utils/data_loader.py

@@ -0,0 +1,36 @@
+"""Data loading utilities for JSON and CSV with environment placeholder support."""
+
+import csv
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+
+ENV_PATTERN = re.compile(r"^\$\{(?P<name>[A-Z0-9_]+)\}$")
+
+
+def _resolve_env_placeholders(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {k: _resolve_env_placeholders(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_resolve_env_placeholders(item) for item in value]
+    if isinstance(value, str):
+        match = ENV_PATTERN.match(value)
+        if match:
+            return os.getenv(match.group("name"), "")
+    return value
+
+
+def load_json(file_path: str) -> Any:
+    """Load and return JSON content from a file path."""
+    with Path(file_path).open("r", encoding="utf-8") as file:
+        return _resolve_env_placeholders(json.load(file))
+
+
+def load_csv(file_path: str) -> list[dict[str, str]]:
+    """Load and return CSV rows as list of dictionaries."""
+    with Path(file_path).open("r", encoding="utf-8", newline="") as file:
+        rows = list(csv.DictReader(file))
+    return _resolve_env_placeholders(rows)