selenium-selector-autocorrect 0.1.0__py3-none-any.whl

selenium_selector_autocorrect/__init__.py

@@ -0,0 +1,54 @@
+"""Selenium Selector AutoCorrect
+
+A Python package that automatically corrects Selenium element selectors using AI
+when they fail, reducing test maintenance and improving test reliability.
+
+Usage:
+    from selenium_selector_autocorrect import install_auto_correct_hook
+    
+    install_auto_correct_hook()
+
+Environment Variables:
+    LOCAL_AI_API_URL: URL of local AI service (default: http://localhost:8765)
+    SELENIUM_AUTO_CORRECT: Enable auto-correction (default: "1")
+    SELENIUM_SUGGEST_BETTER: Suggest better selectors for found elements (default: "0")
+    SELENIUM_AUTO_UPDATE_TESTS: Auto-update test files with corrections (default: "0")
+"""
+
+__version__ = "1.0.0"
+
+from .ai_providers import AIProvider, LocalAIProvider, configure_provider, get_provider
+from .auto_correct import (
+    SelectorAutoCorrect,
+    configure_auto_correct,
+    get_auto_correct,
+    set_auto_correct_enabled,
+)
+from .correction_tracker import (
+    CorrectionTracker,
+    apply_corrections_to_test_files,
+    export_corrections_report,
+    get_correction_tracker,
+    record_correction,
+)
+from .wait_hook import install_auto_correct_hook, uninstall_auto_correct_hook
+
+__all__ = [
+    "__version__",
+    "SelectorAutoCorrect",
+    "get_auto_correct",
+    "set_auto_correct_enabled",
+    "configure_auto_correct",
+    "CorrectionTracker",
+    "get_correction_tracker",
+    "record_correction",
+    "apply_corrections_to_test_files",
+    "export_corrections_report",
+    "AIProvider",
+    "LocalAIProvider",
+    "get_provider",
+    "configure_provider",
+    "install_auto_correct_hook",
+    "uninstall_auto_correct_hook",
+]
+

selenium_selector_autocorrect/ai_providers.py

@@ -0,0 +1,123 @@
+"""AI provider for selector auto-correction using local AI service."""
+
+import logging
+import os
+from abc import ABC, abstractmethod
+from typing import Optional
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class AIProvider(ABC):
+    """Abstract base class for AI providers."""
+
+    @abstractmethod
+    def suggest_selector(self, system_prompt: str, user_prompt: str) -> Optional[str]:
+        """Request a selector suggestion from the AI service.
+        
+        Args:
+            system_prompt: System-level instructions for the AI
+            user_prompt: User query with failed selector and page context
+            
+        Returns:
+            JSON string with suggestion or None if failed
+        """
+        pass
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if the provider is available and operational."""
+        pass
+
+
+class LocalAIProvider(AIProvider):
+    """AI provider using local AI service with OpenAI-compatible API.
+    
+    Args:
+        base_url: URL of the local AI service. If None, reads from
+                  LOCAL_AI_API_URL environment variable (default: http://localhost:8765)
+    """
+
+    def __init__(self, base_url: str = None):
+        self.base_url = base_url or os.environ.get("LOCAL_AI_API_URL", "http://localhost:8765")
+        self._available = None
+    
+    def is_available(self) -> bool:
+        if self._available is not None:
+            return self._available
+        try:
+            response = requests.post(
+                f"{self.base_url}/v1/chat/completions",
+                json={"messages": [{"role": "user", "content": "test"}], "max_tokens": 1},
+                timeout=5
+            )
+            self._available = response.status_code in (200, 400)
+        except Exception as e:
+            logger.info(f"Local AI service not available at {self.base_url}: {e}")
+            self._available = False
+        return self._available
+    
+    def suggest_selector(self, system_prompt: str, user_prompt: str) -> Optional[str]:
+        """Request a selector suggestion from the local AI service.
+        
+        Args:
+            system_prompt: System message describing the task
+            user_prompt: User message with page context and failed selector
+            
+        Returns:
+            AI response text or None if request fails
+        """
+        try:
+            response = requests.post(
+                f"{self.base_url}/v1/chat/completions",
+                json={
+                    "messages": [
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt}
+                    ],
+                    "temperature": 0.3,
+                    "max_tokens": 500
+                },
+                timeout=30
+            )
+            response.raise_for_status()
+            data = response.json()
+            return data.get("choices", [{}])[0].get("message", {}).get("content", "")
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 503:
+                logger.info(f"Local AI service unavailable (503). Disabling auto-correction.")
+                self._available = False
+            else:
+                logger.warning(f"Local AI HTTP error: {e}")
+            return None
+        except Exception as e:
+            logger.warning(f"Local AI request failed: {e}")
+            self._available = False
+            return None
+
+
+def get_provider() -> AIProvider:
+    """Get the configured AI provider.
+    
+    Returns:
+        LocalAIProvider instance
+    """
+    global _provider_instance
+    if _provider_instance is None:
+        _provider_instance = LocalAIProvider()
+    return _provider_instance
+
+
+def configure_provider(provider: AIProvider):
+    """Set a custom AI provider.
+    
+    Args:
+        provider: Instance of AIProvider to use
+    """
+    global _provider_instance
+    _provider_instance = provider
+
+
+_provider_instance = None

selenium_selector_autocorrect/auto_correct.py

@@ -0,0 +1,254 @@
+"""Core selector auto-correction functionality for Selenium WebDriver."""
+
+import json
+import logging
+import os
+import re
+from typing import Any, Dict, Optional, Tuple
+
+from .ai_providers import get_provider
+
+logger = logging.getLogger(__name__)
+
+
+class SelectorAutoCorrect:
+    """Auto-corrects element selectors by analyzing the page and requesting AI suggestions.
+    
+    Args:
+        enabled: Whether auto-correction is enabled
+    """
+
+    def __init__(self, enabled: bool = True):
+        self.enabled = enabled
+        self._provider = None
+        self._correction_cache: Dict[str, str] = {}
+        self._suggestion_cache: Dict[str, str] = {}
+        self.suggest_better_selectors = os.environ.get("SELENIUM_SUGGEST_BETTER", "0").lower() in ("1", "true", "yes")
+        self._confidence_threshold = 50
+        self._cache_enabled = True
+
+    @property
+    def provider(self):
+        if self._provider is None:
+            self._provider = get_provider()
+        return self._provider
+
+    def set_provider(self, provider) -> None:
+        self._provider = provider
+
+    def is_service_available(self) -> bool:
+        if not self.enabled:
+            return False
+        provider = self.provider
+        return provider is not None and provider.is_available()
+
+    def get_visible_elements_summary(self, driver) -> str:
+        try:
+            script = """
+            function getElementSummary() {
+                const selectors = ['input', 'button', 'a', 'select', 'textarea',
+                    '[role="button"]', '[role="link"]', '[data-testid]', '[data-test]', '[id]', '[name]'];
+                const elements = [];
+                selectors.forEach(selector => {
+                    document.querySelectorAll(selector).forEach(el => {
+                        if (el.offsetParent !== null) {
+                            const info = {
+                                tag: el.tagName.toLowerCase(),
+                                id: el.id || null,
+                                name: el.getAttribute('name') || null,
+                                class: el.className || null,
+                                type: el.getAttribute('type') || null,
+                                text: (el.innerText || '').substring(0, 50),
+                                placeholder: el.getAttribute('placeholder') || null,
+                                ariaLabel: el.getAttribute('aria-label') || null,
+                                dataTestId: el.getAttribute('data-testid') || el.getAttribute('data-test') || null,
+                                role: el.getAttribute('role') || null
+                            };
+                            if (info.id || info.name || info.dataTestId || info.text || info.ariaLabel) {
+                                elements.push(info);
+                            }
+                        }
+                    });
+                });
+                const seen = new Set();
+                return elements.filter(el => {
+                    const key = JSON.stringify(el);
+                    if (seen.has(key)) return false;
+                    seen.add(key);
+                    return true;
+                }).slice(0, 100);
+            }
+            return JSON.stringify(getElementSummary());
+            """
+            result = driver.execute_script(script)
+            return result if result else "[]"
+        except Exception as e:
+            logger.warning(f"Failed to get element summary: {e}")
+            return "[]"
+
+    def suggest_selector(self, driver, failed_by: str, failed_value: str, error_message: str = "") -> Optional[Tuple[str, str]]:
+        if not self.enabled or not self.is_service_available():
+            return None
+
+        cache_key = f"{failed_by}:{failed_value}"
+        if self._cache_enabled and cache_key in self._correction_cache:
+            logger.info(f"[AUTO-CORRECT] Using cached correction for {failed_value[:50]}")
+            return self._parse_selector_suggestion(self._correction_cache[cache_key])
+
+        try:
+            elements_summary = self.get_visible_elements_summary(driver)
+            current_url = driver.current_url
+
+            system_prompt = """You are an expert at fixing Selenium element selectors.
+When given a failed selector and available elements, suggest a working alternative.
+ONLY respond with a JSON object containing:
+- "by": the selector strategy ("css selector", "xpath", "id", "name", etc.)
+- "value": the selector value
+- "confidence": a number 0-100
+- "reason": brief explanation
+
+If no good alternative exists, respond with:
+{"by": null, "value": null, "confidence": 0, "reason": "No suitable alternative found"}"""
+
+            user_prompt = f"""The following selector failed:
+- Strategy: {failed_by}
+- Value: {failed_value}
+- URL: {current_url}
+- Error: {error_message}
+
+Available Elements:
+```json
+{elements_summary}
+```
+
+Suggest a working selector. Respond with ONLY a JSON object."""
+
+            logger.info(f"[AUTO-CORRECT] Requesting selector suggestion for: {failed_value[:50]}...")
+            response = self.provider.suggest_selector(system_prompt, user_prompt)
+
+            if response:
+                suggestion = self._parse_selector_suggestion(response)
+                if suggestion and self._cache_enabled:
+                    self._correction_cache[cache_key] = response
+                return suggestion
+            else:
+                if self.provider and not self.provider.is_available():
+                    logger.info("[AUTO-CORRECT] Service unavailable, auto-correction disabled for this session")
+                    self.enabled = False
+        except Exception as e:
+            logger.warning(f"[AUTO-CORRECT] Failed to get suggestion: {e}")
+        return None
+
+    def suggest_better_selector(self, driver, current_by: str, current_value: str, element) -> Optional[Tuple[str, str]]:
+        if not self.suggest_better_selectors or not self.enabled or not self.is_service_available():
+            return None
+
+        if current_by in ("id", "name") or (current_by == "css selector" and "[data-testid=" in current_value):
+            return None
+
+        cache_key = f"{current_by}:{current_value}"
+        if self._cache_enabled and cache_key in self._suggestion_cache:
+            cached = self._suggestion_cache[cache_key]
+            if cached == "OPTIMAL":
+                return None
+            return self._parse_selector_suggestion(cached)
+
+        try:
+            element_info = self._get_element_info(element)
+            elements_summary = self.get_visible_elements_summary(driver)
+
+            system_prompt = """You are an expert at improving Selenium element selectors.
+Suggest a better selector ONLY if the current one is fragile.
+Preference: data-testid > id > name > css class > xpath
+
+Respond with JSON: {"by": ..., "value": ..., "confidence": ..., "reason": ...}
+If current is optimal: {"by": null, "value": null, "confidence": 100, "reason": "Current selector is optimal"}"""
+
+            user_prompt = f"""Current Selector: {current_by}='{current_value}'
+Element attributes: {json.dumps(element_info, indent=2)}
+Available Elements:
+```json
+{elements_summary}
+```"""
+
+            response = self.provider.suggest_selector(system_prompt, user_prompt)
+            if response:
+                suggestion = self._parse_selector_suggestion(response)
+                if suggestion:
+                    if self._cache_enabled:
+                        self._suggestion_cache[cache_key] = response
+                    return suggestion
+                else:
+                    if self._cache_enabled:
+                        self._suggestion_cache[cache_key] = "OPTIMAL"
+        except Exception as e:
+            logger.debug(f"[SUGGEST] Failed to get better selector: {e}")
+        return None
+
+    def _get_element_info(self, element) -> Dict[str, Any]:
+        try:
+            info = {
+                "tag": element.tag_name,
+                "id": element.get_attribute("id"),
+                "name": element.get_attribute("name"),
+                "class": element.get_attribute("class"),
+                "data-testid": element.get_attribute("data-testid") or element.get_attribute("data-test"),
+                "aria-label": element.get_attribute("aria-label"),
+            }
+            return {k: v for k, v in info.items() if v}
+        except Exception:
+            return {}
+
+    def _parse_selector_suggestion(self, content: str) -> Optional[Tuple[str, str]]:
+        try:
+            json_match = re.search(r'\{[^{}]*\}', content, re.DOTALL)
+            if json_match:
+                data = json.loads(json_match.group())
+                by = data.get("by")
+                value = data.get("value")
+                confidence = data.get("confidence", 0)
+                reason = data.get("reason", "")
+
+                if by and value and confidence >= self._confidence_threshold:
+                    logger.info(f"[AUTO-CORRECT] Suggested selector (confidence: {confidence}%)")
+                    logger.info(f"   Strategy: {by}")
+                    logger.info(f"   Value: {value}")
+                    logger.info(f"   Reason: {reason}")
+                    return (by, value)
+                elif reason:
+                    logger.info(f"[AUTO-CORRECT] No good suggestion - {reason}")
+        except json.JSONDecodeError as e:
+            logger.warning(f"[AUTO-CORRECT] Failed to parse JSON: {e}")
+        except Exception as e:
+            logger.warning(f"[AUTO-CORRECT] Error parsing suggestion: {e}")
+        return None
+
+    def clear_cache(self):
+        self._correction_cache.clear()
+        self._suggestion_cache.clear()
+
+
+_auto_correct_instance: Optional[SelectorAutoCorrect] = None
+
+
+def get_auto_correct() -> SelectorAutoCorrect:
+    """Get the global SelectorAutoCorrect instance."""
+    global _auto_correct_instance
+    if _auto_correct_instance is None:
+        enabled = os.environ.get("SELENIUM_AUTO_CORRECT", "1").lower() in ("1", "true", "yes")
+        _auto_correct_instance = SelectorAutoCorrect(enabled=enabled)
+    return _auto_correct_instance
+
+
+def set_auto_correct_enabled(enabled: bool):
+    """Enable or disable auto-correction globally."""
+    get_auto_correct().enabled = enabled
+
+
+def configure_auto_correct(provider=None, enabled: bool = True, suggest_better: bool = False):
+    """Configure auto-correction settings."""
+    auto_correct = get_auto_correct()
+    auto_correct.enabled = enabled
+    auto_correct.suggest_better_selectors = suggest_better
+    if provider:
+        auto_correct.set_provider(provider)

selenium_selector_autocorrect/correction_tracker.py

@@ -0,0 +1,226 @@
+"""Correction tracker for recording and applying selector fixes."""
+
+import json
+import logging
+import os
+import traceback
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class CorrectionTracker:
+    """Tracks selector corrections and manages test file updates."""
+
+    def __init__(self):
+        self._corrections: List[Dict[str, Any]] = []
+        self._local_ai_url = os.environ.get("LOCAL_AI_API_URL", "http://localhost:8765")
+        self._auto_update_enabled = os.environ.get("SELENIUM_AUTO_UPDATE_TESTS", "0").lower() in ("1", "true", "yes")
+
+    def record_correction(
+        self,
+        original_by: str,
+        original_value: str,
+        corrected_by: str,
+        corrected_value: str,
+        success: bool = True,
+        test_file: Optional[str] = None,
+        test_line: Optional[int] = None
+    ):
+        if test_file is None or test_line is None:
+            # Extract from stack trace, prioritizing actual test files
+            for frame in traceback.extract_stack():
+                filename = frame.filename.replace('\\', '/')
+                filename_lower = filename.lower()
+                # Skip selenium packages, pytest, and our autocorrect packages
+                # Be specific to avoid skipping directories with "selenium" in the name
+                if ('/selenium/' in filename_lower or 
+                    '\\selenium\\' in filename or
+                    '/site-packages/selenium/' in filename_lower or
+                    '/pytest' in filename_lower or
+                    '/_pytest' in filename_lower or
+                    '/selenium_selector_autocorrect/' in filename_lower or
+                    '\\selenium_selector_autocorrect\\' in filename):
+                    continue
+                # Prioritize test files, then page objects, then ui_client
+                if ('test_library' in filename or
+                    'test_' in filename or
+                    'page_factory' in filename_lower or
+                    'ui_client' in filename_lower):
+                    test_file = filename
+                    test_line = frame.lineno
+                    # Don't break - keep looking for test files specifically
+                    if 'test_' in filename or 'test_library' in filename:
+                        break
+
+        correction = {
+            "original_by": original_by,
+            "original_value": original_value,
+            "corrected_by": corrected_by,
+            "corrected_value": corrected_value,
+            "success": success,
+            "test_file": test_file,
+            "test_line": test_line,
+            "timestamp": datetime.now().isoformat()
+        }
+        self._corrections.append(correction)
+
+        try:
+            logger.info(f"[CORRECTION TRACKED] {original_by}='{original_value[:30]}...' -> {corrected_by}='{corrected_value[:30]}...'")
+            if test_file:
+                logger.info(f"[CORRECTION SOURCE] File: {test_file}, Line: {test_line}")
+        except Exception:
+            pass
+
+        if self._auto_update_enabled and success and test_file:
+            logger.info(f"[AUTO-UPDATE] Attempting to update {test_file}...")
+            self._auto_update_test_file(correction)
+
+    def get_corrections(self) -> List[Dict[str, Any]]:
+        return self._corrections.copy()
+
+    def get_successful_corrections(self) -> List[Dict[str, Any]]:
+        return [c for c in self._corrections if c.get("success", False)]
+
+    def clear_corrections(self):
+        self._corrections.clear()
+
+    def _auto_update_test_file(self, correction: Dict[str, Any]):
+        try:
+            test_file = correction.get("test_file")
+            if not test_file:
+                return
+            result = self.update_test_file_via_service(
+                test_file,
+                correction["original_by"],
+                correction["original_value"],
+                correction["corrected_by"],
+                correction["corrected_value"]
+            )
+            if result.get("success"):
+                logger.info(f"[AUTO-UPDATE] Successfully updated {test_file}")
+            else:
+                logger.warning(f"[AUTO-UPDATE] Failed to update {test_file}: {result.get('errors', [])}")
+        except Exception as e:
+            logger.warning(f"[AUTO-UPDATE] Error updating test file: {e}")
+
+    def update_test_file_via_service(
+        self,
+        file_path: str,
+        original_by: str,
+        original_value: str,
+        corrected_by: str,
+        corrected_value: str
+    ) -> Dict[str, Any]:
+        try:
+            read_url = f"{self._local_ai_url}/v1/workspace/files/read"
+            read_response = requests.post(read_url, json={"filePath": file_path}, timeout=30)
+            read_response.raise_for_status()
+            file_content = read_response.json()
+
+            if not file_content.get("success"):
+                return {"success": False, "errors": ["Could not read file"]}
+
+            content = file_content.get("content", "")
+            old_patterns = [
+                f'"{original_value}"',
+                f"'{original_value}'",
+            ]
+
+            found_pattern = None
+            new_pattern = None
+            for old_pattern in old_patterns:
+                if old_pattern in content:
+                    found_pattern = old_pattern
+                    new_pattern = f'"{corrected_value}"' if old_pattern.startswith('"') else f"'{corrected_value}'"
+                    break
+
+            if not found_pattern:
+                return {"success": False, "errors": [f"Could not find selector: {original_value[:50]}..."]}
+
+            edit_url = f"{self._local_ai_url}/v1/workspace/files/edit"
+            edit_response = requests.post(
+                edit_url,
+                json={"filePath": file_path, "oldString": found_pattern, "newString": new_pattern},
+                timeout=30
+            )
+            edit_response.raise_for_status()
+            return edit_response.json()
+        except requests.exceptions.ConnectionError:
+            logger.warning(f"[LOCAL AI SERVICE] Not available at {self._local_ai_url}")
+            return {"success": False, "errors": ["Local AI service not available"]}
+        except Exception as e:
+            logger.warning(f"[UPDATE ERROR] {e}")
+            return {"success": False, "errors": [str(e)]}
+
+    def export_corrections_report(self, output_file: str = "selector_corrections.json"):
+        with open(output_file, "w") as f:
+            json.dump({
+                "corrections": self._corrections,
+                "summary": {
+                    "total": len(self._corrections),
+                    "successful": len(self.get_successful_corrections()),
+                    "generated_at": datetime.now().isoformat()
+                }
+            }, f, indent=2)
+        logger.info(f"[CORRECTIONS REPORT] Exported to {output_file}")
+
+    def apply_all_corrections_to_files(self) -> Dict[str, Any]:
+        results = {"total": 0, "success": 0, "failed": 0, "details": []}
+        for correction in self.get_successful_corrections():
+            test_file = correction.get("test_file")
+            if not test_file:
+                continue
+            results["total"] += 1
+            result = self.update_test_file_via_service(
+                test_file,
+                correction["original_by"],
+                correction["original_value"],
+                correction["corrected_by"],
+                correction["corrected_value"]
+            )
+            if result.get("success"):
+                results["success"] += 1
+            else:
+                results["failed"] += 1
+            results["details"].append({
+                "file": test_file,
+                "original": correction["original_value"][:50],
+                "corrected": correction["corrected_value"][:50],
+                "result": result
+            })
+        logger.info(f"[APPLIED CORRECTIONS] {results['success']}/{results['total']} successful")
+        return results
+
+
+_correction_tracker: Optional[CorrectionTracker] = None
+
+
+def get_correction_tracker() -> CorrectionTracker:
+    """Get the global CorrectionTracker instance."""
+    global _correction_tracker
+    if _correction_tracker is None:
+        _correction_tracker = CorrectionTracker()
+    return _correction_tracker
+
+
+def record_correction(
+    original_by: str, original_value: str, corrected_by: str, corrected_value: str, success: bool = True
+):
+    """Record a selector correction."""
+    get_correction_tracker().record_correction(
+        original_by, original_value, corrected_by, corrected_value, success
+    )
+
+
+def apply_corrections_to_test_files() -> Dict[str, Any]:
+    """Apply all successful corrections to their source test files."""
+    return get_correction_tracker().apply_all_corrections_to_files()
+
+
+def export_corrections_report(output_file: str = "selector_corrections.json"):
+    """Export corrections report to JSON file."""
+    get_correction_tracker().export_corrections_report(output_file)

selenium_selector_autocorrect/py.typed

@@ -0,0 +1 @@
+# Type hints marker for PEP 561

selenium_selector_autocorrect/wait_hook.py

@@ -0,0 +1,140 @@
+"""WebDriverWait integration hook for selector auto-correction."""
+
+import logging
+import time
+from typing import Callable, Optional
+
+from selenium.common.exceptions import TimeoutException
+from selenium.webdriver.remote.webelement import WebElement
+from selenium.webdriver.support.wait import WebDriverWait
+
+from .auto_correct import get_auto_correct
+from .correction_tracker import record_correction
+
+logger = logging.getLogger(__name__)
+
+_original_until = WebDriverWait.until
+
+
+def _patched_until(self, method: Callable, message: str = ""):
+    """Patched until method with auto-correct support."""
+    screen = None
+    stacktrace = None
+
+    end_time = time.monotonic() + self._timeout
+    while True:
+        try:
+            value = method(self._driver)
+            if value:
+                return value
+        except self._ignored_exceptions as exc:
+            screen = getattr(exc, "screen", None)
+            stacktrace = getattr(exc, "stacktrace", None)
+        if time.monotonic() > end_time:
+            break
+        time.sleep(self._poll)
+
+    auto_correct = get_auto_correct()
+    if auto_correct.enabled:
+        locator = _extract_locator_from_method(method)
+        if locator:
+            by, value_str = locator
+            logger.warning(
+                f"[AUTO-CORRECT] Timeout waiting for element {by}='{value_str[:80]}...' - attempting auto-correction"
+            )
+
+            driver = self._driver
+            if isinstance(driver, WebElement):
+                driver = driver.parent
+
+            suggestion = auto_correct.suggest_selector(
+                driver,
+                failed_by=by,
+                failed_value=value_str,
+                error_message=message or f"Timeout waiting for element with {by}={value_str}",
+            )
+
+            if suggestion:
+                suggested_by, suggested_value = suggestion
+                logger.warning(f"[AUTO-CORRECT] Trying suggested selector: {suggested_by}='{suggested_value}'")
+
+                corrected_method = _create_corrected_method(method, suggested_by, suggested_value)
+                if corrected_method:
+                    try:
+                        result = corrected_method(self._driver)
+                        if result:
+                            logger.warning(f"[AUTO-CORRECT] SUCCESS! Element found with corrected selector")
+                            record_correction(
+                                original_by=by,
+                                original_value=value_str,
+                                corrected_by=suggested_by,
+                                corrected_value=suggested_value,
+                                success=True,
+                            )
+                            return result
+                    except Exception as e:
+                        logger.warning(f"[AUTO-CORRECT] Suggested selector also failed: {e}")
+
+    raise TimeoutException(message, screen, stacktrace)
+
+
+def _extract_locator_from_method(method: Callable) -> Optional[tuple]:
+    """Extract locator tuple (by, value) from an expected_conditions method."""
+    try:
+        if hasattr(method, "locator"):
+            logger.debug(f"[AUTO-CORRECT] Found locator attribute: {method.locator}")
+            return method.locator
+
+        if hasattr(method, "__closure__") and method.__closure__:
+            for cell in method.__closure__:
+                cell_contents = cell.cell_contents
+                logger.debug(f"[AUTO-CORRECT] Checking closure cell: {type(cell_contents)} = {cell_contents}")
+                if isinstance(cell_contents, tuple) and len(cell_contents) == 2:
+                    if isinstance(cell_contents[0], str) and isinstance(cell_contents[1], str):
+                        logger.debug(f"[AUTO-CORRECT] Extracted locator from closure: {cell_contents}")
+                        return cell_contents
+        logger.warning(f"[AUTO-CORRECT] Could not extract locator from method: {method}")
+    except Exception as e:
+        logger.exception(f"[AUTO-CORRECT] Error extracting locator: {e}")
+    return None
+
+
+def _create_corrected_method(original_method: Callable, new_by: str, new_value: str) -> Optional[Callable]:
+    """Create a new expected condition method with corrected locator."""
+    try:
+        from selenium.webdriver.support import expected_conditions as EC
+        
+        method_name = None
+        if hasattr(original_method, '__qualname__'):
+            qualname = original_method.__qualname__
+            if '.<locals>._predicate' in qualname:
+                method_name = qualname.split('.<locals>._predicate')[0]
+        
+        if not method_name:
+            method_name = original_method.__class__.__name__
+        
+        method_map = {
+            "visibility_of_element_located": EC.visibility_of_element_located,
+            "presence_of_element_located": EC.presence_of_element_located,
+            "element_to_be_clickable": EC.element_to_be_clickable,
+            "invisibility_of_element_located": EC.invisibility_of_element_located,
+        }
+        
+        ec_method = method_map.get(method_name, EC.visibility_of_element_located)
+        return ec_method((new_by, new_value))
+        
+    except Exception as e:
+        logger.exception(f"[AUTO-CORRECT] Error creating corrected method: {e}")
+        return None
+
+
+def install_auto_correct_hook():
+    """Install the auto-correct hook into WebDriverWait."""
+    WebDriverWait.until = _patched_until
+    logger.info("[AUTO-CORRECT] Hook installed into WebDriverWait")
+
+
+def uninstall_auto_correct_hook():
+    """Remove the auto-correct hook from WebDriverWait."""
+    WebDriverWait.until = _original_until
+    logger.info("[AUTO-CORRECT] Hook removed from WebDriverWait")

selenium_selector_autocorrect-0.1.0.dist-info/METADATA

@@ -0,0 +1,277 @@
+Metadata-Version: 2.4
+Name: selenium-selector-autocorrect
+Version: 0.1.0
+Summary: Automatic Selenium selector correction using AI when elements fail to be found
+Author-email: Marty Zhou <marty.zhou@example.com>
+Maintainer-email: Marty Zhou <marty.zhou@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/MartyZhou/selenium-selector-autocorrect
+Project-URL: Documentation, https://github.com/MartyZhou/selenium-selector-autocorrect#readme
+Project-URL: Repository, https://github.com/MartyZhou/selenium-selector-autocorrect
+Project-URL: Issues, https://github.com/MartyZhou/selenium-selector-autocorrect/issues
+Project-URL: Changelog, https://github.com/MartyZhou/selenium-selector-autocorrect/blob/main/CHANGELOG.md
+Keywords: selenium,testing,automation,ai,web-testing,test-automation,selector,auto-correction
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Framework :: Pytest
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: selenium>=4.0.0
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# Selenium Selector AutoCorrect
+
+A Python package that automatically corrects Selenium element selectors using AI when they fail, reducing test maintenance and improving test reliability.
+
+## Features
+
+- **Automatic Selector Correction**: When a WebDriverWait times out, the package uses AI to analyze the page and suggest working alternatives
+- **Local AI Integration**: Uses a local AI service with OpenAI-compatible API
+- **Correction Tracking**: Records all corrections with source file and line information
+- **Optional Auto-Update**: Can automatically update test files with corrected selectors
+- **Zero Code Changes**: Works by hooking into Selenium's WebDriverWait
+
+## Installation
+
+```bash
+pip install selenium-selector-autocorrect
+```
+
+## Quick Start
+
+```python
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.wait import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium_selector_autocorrect import install_auto_correct_hook
+
+install_auto_correct_hook()
+
+driver = webdriver.Chrome()
+driver.get("https://example.com")
+
+element = WebDriverWait(driver, 10).until(
+    EC.presence_of_element_located((By.ID, "some-element"))
+)
+```
+
+## AI Service Setup
+
+This package requires a local AI service with an OpenAI-compatible API. We recommend using **[VS Code Copilot as Service](https://marketplace.visualstudio.com/items?itemName=MartyZhou.vscode-copilot-as-service)**, which exposes GitHub Copilot through a local HTTP server.
+
+### Installing VS Code Copilot as Service
+
+1. Install from VS Code Marketplace or run:
+   ```bash
+   code --install-extension MartyZhou.vscode-copilot-as-service
+   ```
+
+2. The extension automatically starts a server on `http://localhost:8765`
+
+3. Requires an active GitHub Copilot subscription
+
+
+## Configuration
+
+Configure via environment variables:
+
+- `LOCAL_AI_API_URL`: URL of local AI service (default: `http://localhost:8765`)
+- `SELENIUM_AUTO_CORRECT`: Enable/disable auto-correction (default: `"1"`)
+- `SELENIUM_SUGGEST_BETTER`: Suggest better selectors for found elements (default: `"0"`)
+- `SELENIUM_AUTO_UPDATE_TESTS`: Auto-update test files with corrections (default: `"0"`)
+
+### Example
+
+```python
+import os
+
+os.environ['LOCAL_AI_API_URL'] = 'http://localhost:8765'
+os.environ['SELENIUM_AUTO_CORRECT'] = '1'
+os.environ['SELENIUM_AUTO_UPDATE_TESTS'] = '1'  # Enable auto-update
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+from selenium_selector_autocorrect import install_auto_correct_hook
+
+install_auto_correct_hook()
+```
+
+### Advanced Usage
+
+```python
+from selenium_selector_autocorrect import (
+    install_auto_correct_hook,
+    get_auto_correct,
+    get_correction_tracker,
+    export_corrections_report
+)
+
+install_auto_correct_hook()
+
+auto_correct = get_auto_correct()
+auto_correct.enabled = True
+auto_correct.suggest_better_selectors = False
+
+# Export corrections report at end of test run
+tracker = get_correction_tracker()
+export_corrections_report("corrections_report.json")
+tracker = get_correction_tracker()
+export_corrections_report("corrections_report.json")
+
+print(f"Total corrections: {len(tracker.get_corrections())}")
+print(f"Successful corrections: {len(tracker.get_successful_corrections())}")
+```
+
+### Custom AI Provider
+
+```python
+from selenium_selector_autocorrect import AIProvider, configure_provider
+
+class CustomAIProvider(AIProvider):
+    def is_available(self) -> bool:
+        return True
+    
+    def suggest_selector(self, system_prompt: str, user_prompt: str):))
+```
+
+## How It Works
+
+1. **Hook Installation**: Patches `WebDriverWait.until()` to add auto-correction
+2. **Timeout Detection**: When a selector times out, the original exception is caught
+3. **Page Analysis**: JavaScript extracts visible elements and their attributes
+4. **AI Suggestion**: Sends page context to AI provider for selector suggestion
+5. **Verification**: Tests the suggested selector
+6. **Success Handling**: If successful, records the correction and optionally updates the test file
+7. **Fallback**: If correction fails, raises the original TimeoutException
+
+## AI Provider Setup
+
+### Local AI Service
+
+The package requires a local AI service with OpenAI-compatible API:
+
+```bash
+POST http://localhost:8765/v1/chat/completions
+```
+
+For file auto-updates:
+```bash
+POST http://localhost:8765/v1/workspace/files/read
+POST http://localhost:8765/v1/workspace/files/edit
+## Correction Reports
+
+Export correction reports in JSON format:
+
+```python
+from selenium_selector_autocorrect import export_corrections_report
+
+export_corrections_report("corrections_report.json")
+```
+
+Report format:
+```json
+{
+  "corrections": [
+    {
+      "original_by": "id",
+      "original_value": "old-selector",
+      "corrected_by": "css selector",
+      "corrected_value": ".new-selector",
+      "success": true,
+      "test_file": "/path/to/test.py",
+      "test_line": 42,
+      "timestamp": "2024-01-31T10:30:00"
+    }
+  ],
+  "summary": {
+    "total": 10,
+    "successful": 8,
+    "generated_at": "2024-01-31T10:35:00"
+  }
+}
+```
+
+## Best Practices
+
+1. **Install Once**: Call `install_auto_correct_hook()` once at test suite startup (e.g., in `conftest.py`)
+2. **Review Corrections**: Regularly review correction reports to identify brittle selectors
+3. **Update Tests**: Use auto-update sparingly and review changes before committing
+4. **Monitor AI Service**: Ensure your AI service is running and responsive
+5. **Use Strong Selectors**: The tool helps with failures but writing robust selectors is still preferred
+
+## Requirements
+
+- Python >= 3.8
+- selenium >= 4.0.0
+- requests >= 2.25.0
+
+## License
+
+MITInstall hook once at test suite startup (e.g., in conftest.py)
+2. Review correction reports regularly to identify brittle selectors
+3. Use auto-update sparingly and review changes before committing
+4. Ensure your AI service is running and responsive
+5. Write robust selectors - the tool helps with failures but prevention is better
+
+When contributing:
+1. Follow PEP 8 style guidelines
+2. Add tests for new features
+3. Update documentation
+4. No emojis in code or documentation
+
+## Troubleshooting
+
+### AI Service Not Available
+
+Contributions are welcome! Please:
+1. Follow PEP 8 style guidelines
+2. Add tests for new features
+3. Update documentation
+4. Maintain consistency with existing code
+
+**Possible causes**:
+- `SELENIUM_AUTO_UPDATE_TESTS` not set to `"1"`
+- Test file path not detected correctly
+- Selector string not found in source file (check quotes)
+
+### No Corrections Happening
+Solution: Ensure your local AI service is running on the configured port.
+
+### Test File Not Updated
+
+Possible causes:
+- `SELENIUM_AUTO_UPDATE_TESTS` not set to "1"
+- Test file path not detected correctly
+- Selector string not found in source file
+
+### No Corrections Happening
+
+Check:
+1. Hook is installed - look for log message
+2. AI service is available - check `get_auto_correct().is_service_available()`
+3. Auto-correct is enabled - c
+See CHANGELOG.md for version history and changes.

selenium_selector_autocorrect-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+selenium_selector_autocorrect/__init__.py,sha256=WjF3o-hlNlt_-tlFxQqIQ4P3OT9ZB0MhBYyJc9Ef8Hg,1665
+selenium_selector_autocorrect/ai_providers.py,sha256=c0DHw1Kyfsa6QNF_Yt2zhEGw7-yynZ2_YT7NAXEIn1Y,4095
+selenium_selector_autocorrect/auto_correct.py,sha256=73PhryN0HnMTqhQXZGIy3ahC65IfW2i0IJqf-aOSEVM,10822
+selenium_selector_autocorrect/correction_tracker.py,sha256=tvw7S9q8y-wuPYJ1W8pBP72r8dI0okbVHSjaYhnKGbA,9282
+selenium_selector_autocorrect/py.typed,sha256=FPdf-6Jjb4gsSRLK88ZhHbrQnHD9pcZQTqaxHzO8neM,33
+selenium_selector_autocorrect/wait_hook.py,sha256=U4xD3G3rx6sjcN72qTpH3ET-gY5fhS_X6ADI99CP5uc,5857
+selenium_selector_autocorrect-0.1.0.dist-info/licenses/LICENSE,sha256=VRPy6YXF2wA_3MeTDnpa_-6Zgjt8c2C0D_iIyhDkduc,1095
+selenium_selector_autocorrect-0.1.0.dist-info/METADATA,sha256=mhCjJVP7EoA_n6_VUnHffytUImc-A0kozBntx5TiiHk,9221
+selenium_selector_autocorrect-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+selenium_selector_autocorrect-0.1.0.dist-info/top_level.txt,sha256=nQ78Mk-XHDhYBckP0tMZvoFAZmZGO4Ec4-e1i61Fdz0,30
+selenium_selector_autocorrect-0.1.0.dist-info/RECORD,,

selenium_selector_autocorrect-0.1.0.dist-info/WHEEL

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

selenium_selector_autocorrect-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

selenium_selector_autocorrect-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+selenium_selector_autocorrect