selenium-selector-autocorrect 0.1.0__tar.gz → 0.1.1__tar.gz

{selenium_selector_autocorrect-0.1.0/src/selenium_selector_autocorrect.egg-info → selenium_selector_autocorrect-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: selenium-selector-autocorrect
-Version: 0.1.0
+Version: 0.1.1
 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>

{selenium_selector_autocorrect-0.1.0 → selenium_selector_autocorrect-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "selenium-selector-autocorrect"
-version = "0.1.0"
+version = "0.1.1"
 description = "Automatic Selenium selector correction using AI when elements fail to be found"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -80,11 +80,12 @@ line_length = 120
 src_paths = ["src"]
 
 [tool.mypy]
-python_version = "3.8"
+python_version = "3.9"
 warn_return_any = true
 warn_unused_configs = true
-disallow_untyped_defs = false
-ignore_missing_imports = true
+disallow_untyped_defs = true
+strict = true
+ignore_missing_imports = false
 
 [tool.ruff]
 line-length = 120

{selenium_selector_autocorrect-0.1.0 → selenium_selector_autocorrect-0.1.1}/src/selenium_selector_autocorrect/__init__.py

@@ -15,7 +15,7 @@ Environment Variables:
     SELENIUM_AUTO_UPDATE_TESTS: Auto-update test files with corrections (default: "0")
 """
 
-__version__ = "1.0.0"
+__version__ = "0.1.1"
 
 from .ai_providers import AIProvider, LocalAIProvider, configure_provider, get_provider
 from .auto_correct import (

{selenium_selector_autocorrect-0.1.0 → selenium_selector_autocorrect-0.1.1}/src/selenium_selector_autocorrect/ai_providers.py

@@ -3,7 +3,7 @@
 import logging
 import os
 from abc import ABC, abstractmethod
-from typing import Optional
+from typing import Any, Dict, Optional
 
 import requests
 
@@ -40,9 +40,9 @@ class LocalAIProvider(AIProvider):
                   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 __init__(self, base_url: Optional[str] = None) -> None:
+        self.base_url: str = base_url or os.environ.get("LOCAL_AI_API_URL", "http://localhost:8765")
+        self._available: Optional[bool] = None
     
     def is_available(self) -> bool:
         if self._available is not None:
@@ -83,8 +83,9 @@ class LocalAIProvider(AIProvider):
                 timeout=30
             )
             response.raise_for_status()
-            data = response.json()
-            return data.get("choices", [{}])[0].get("message", {}).get("content", "")
+            data: Dict[str, Any] = response.json()
+            content: Optional[str] = data.get("choices", [{}])[0].get("message", {}).get("content", "")
+            return content
         except requests.exceptions.HTTPError as e:
             if e.response.status_code == 503:
                 logger.info(f"Local AI service unavailable (503). Disabling auto-correction.")
@@ -110,7 +111,7 @@ def get_provider() -> AIProvider:
     return _provider_instance
 
 
-def configure_provider(provider: AIProvider):
+def configure_provider(provider: AIProvider) -> None:
     """Set a custom AI provider.
     
     Args:
@@ -120,4 +121,4 @@ def configure_provider(provider: AIProvider):
     _provider_instance = provider
 
 
-_provider_instance = None
+_provider_instance: Optional[AIProvider] = None

{selenium_selector_autocorrect-0.1.0 → selenium_selector_autocorrect-0.1.1}/src/selenium_selector_autocorrect/auto_correct.py

@@ -4,9 +4,13 @@ import json
 import logging
 import os
 import re
-from typing import Any, Dict, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
 
-from .ai_providers import get_provider
+from .ai_providers import AIProvider, get_provider
+
+if TYPE_CHECKING:
+    from selenium.webdriver.remote.webdriver import WebDriver
+    from selenium.webdriver.remote.webelement import WebElement
 
 logger = logging.getLogger(__name__)
 
@@ -18,22 +22,22 @@ class SelectorAutoCorrect:
         enabled: Whether auto-correction is enabled
     """
 
-    def __init__(self, enabled: bool = True):
-        self.enabled = enabled
-        self._provider = None
+    def __init__(self, enabled: bool = True) -> None:
+        self.enabled: bool = enabled
+        self._provider: Optional[AIProvider] = 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
+        self.suggest_better_selectors: bool = os.environ.get("SELENIUM_SUGGEST_BETTER", "0").lower() in ("1", "true", "yes")
+        self._confidence_threshold: int = 50
+        self._cache_enabled: bool = True
 
     @property
-    def provider(self):
+    def provider(self) -> AIProvider:
         if self._provider is None:
             self._provider = get_provider()
         return self._provider
 
-    def set_provider(self, provider) -> None:
+    def set_provider(self, provider: AIProvider) -> None:
         self._provider = provider
 
     def is_service_available(self) -> bool:
@@ -42,7 +46,7 @@ class SelectorAutoCorrect:
         provider = self.provider
         return provider is not None and provider.is_available()
 
-    def get_visible_elements_summary(self, driver) -> str:
+    def get_visible_elements_summary(self, driver: "WebDriver") -> str:
         try:
             script = """
             function getElementSummary() {
@@ -86,7 +90,13 @@ class SelectorAutoCorrect:
             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]]:
+    def suggest_selector(
+        self,
+        driver: "WebDriver",
+        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
 
@@ -139,7 +149,13 @@ Suggest a working selector. Respond with ONLY a JSON object."""
             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]]:
+    def suggest_better_selector(
+        self,
+        driver: "WebDriver",
+        current_by: str,
+        current_value: str,
+        element: "WebElement"
+    ) -> Optional[Tuple[str, str]]:
         if not self.suggest_better_selectors or not self.enabled or not self.is_service_available():
             return None
 
@@ -182,12 +198,12 @@ Available Elements:
                     if self._cache_enabled:
                         self._suggestion_cache[cache_key] = "OPTIMAL"
         except Exception as e:
-            logger.debug(f"[SUGGEST] Failed to get better selector: {e}")
+            logger.debug(f"[AUTO-SUGGEST] Failed to get better selector: {e}")
         return None
 
-    def _get_element_info(self, element) -> Dict[str, Any]:
+    def _get_element_info(self, element: "WebElement") -> Dict[str, Any]:
         try:
-            info = {
+            info: Dict[str, Any] = {
                 "tag": element.tag_name,
                 "id": element.get_attribute("id"),
                 "name": element.get_attribute("name"),
@@ -223,7 +239,7 @@ Available Elements:
             logger.warning(f"[AUTO-CORRECT] Error parsing suggestion: {e}")
         return None
 
-    def clear_cache(self):
+    def clear_cache(self) -> None:
         self._correction_cache.clear()
         self._suggestion_cache.clear()
 
@@ -240,12 +256,16 @@ def get_auto_correct() -> SelectorAutoCorrect:
     return _auto_correct_instance
 
 
-def set_auto_correct_enabled(enabled: bool):
+def set_auto_correct_enabled(enabled: bool) -> None:
     """Enable or disable auto-correction globally."""
     get_auto_correct().enabled = enabled
 
 
-def configure_auto_correct(provider=None, enabled: bool = True, suggest_better: bool = False):
+def configure_auto_correct(
+    provider: Optional[AIProvider] = None,
+    enabled: bool = True,
+    suggest_better: bool = False
+) -> None:
     """Configure auto-correction settings."""
     auto_correct = get_auto_correct()
     auto_correct.enabled = enabled

{selenium_selector_autocorrect-0.1.0 → selenium_selector_autocorrect-0.1.1}/src/selenium_selector_autocorrect/correction_tracker.py

@@ -5,20 +5,40 @@ import logging
 import os
 import traceback
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, TypedDict
 
 import requests
 
 logger = logging.getLogger(__name__)
 
 
+class CorrectionRecord(TypedDict, total=False):
+    """Type definition for a correction record."""
+    original_by: str
+    original_value: str
+    corrected_by: str
+    corrected_value: str
+    success: bool
+    test_file: Optional[str]
+    test_line: Optional[int]
+    timestamp: str
+
+
+class ApplyCorrectionsResult(TypedDict):
+    """Type definition for apply_all_corrections result."""
+    total: int
+    success: int
+    failed: int
+    details: List[Dict[str, Any]]
+
+
 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 __init__(self) -> None:
+        self._corrections: List[CorrectionRecord] = []
+        self._local_ai_url: str = os.environ.get("LOCAL_AI_API_URL", "http://localhost:8765")
+        self._auto_update_enabled: bool = os.environ.get("SELENIUM_AUTO_UPDATE_TESTS", "0").lower() in ("1", "true", "yes")
 
     def record_correction(
         self,
@@ -29,7 +49,7 @@ class CorrectionTracker:
         success: bool = True,
         test_file: Optional[str] = None,
         test_line: Optional[int] = None
-    ):
+    ) -> 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():
@@ -56,7 +76,7 @@ class CorrectionTracker:
                     if 'test_' in filename or 'test_library' in filename:
                         break
 
-        correction = {
+        correction: CorrectionRecord = {
             "original_by": original_by,
             "original_value": original_value,
             "corrected_by": corrected_by,
@@ -79,16 +99,16 @@ class CorrectionTracker:
             logger.info(f"[AUTO-UPDATE] Attempting to update {test_file}...")
             self._auto_update_test_file(correction)
 
-    def get_corrections(self) -> List[Dict[str, Any]]:
+    def get_corrections(self) -> List[CorrectionRecord]:
         return self._corrections.copy()
 
-    def get_successful_corrections(self) -> List[Dict[str, Any]]:
+    def get_successful_corrections(self) -> List[CorrectionRecord]:
         return [c for c in self._corrections if c.get("success", False)]
 
-    def clear_corrections(self):
+    def clear_corrections(self) -> None:
         self._corrections.clear()
 
-    def _auto_update_test_file(self, correction: Dict[str, Any]):
+    def _auto_update_test_file(self, correction: CorrectionRecord) -> None:
         try:
             test_file = correction.get("test_file")
             if not test_file:
@@ -148,7 +168,8 @@ class CorrectionTracker:
                 timeout=30
             )
             edit_response.raise_for_status()
-            return edit_response.json()
+            result: Dict[str, Any] = edit_response.json()
+            return result
         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"]}
@@ -156,7 +177,7 @@ class CorrectionTracker:
             logger.warning(f"[UPDATE ERROR] {e}")
             return {"success": False, "errors": [str(e)]}
 
-    def export_corrections_report(self, output_file: str = "selector_corrections.json"):
+    def export_corrections_report(self, output_file: str = "selector_corrections.json") -> None:
         with open(output_file, "w") as f:
             json.dump({
                 "corrections": self._corrections,
@@ -168,8 +189,8 @@ class CorrectionTracker:
             }, 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": []}
+    def apply_all_corrections_to_files(self) -> ApplyCorrectionsResult:
+        results: ApplyCorrectionsResult = {"total": 0, "success": 0, "failed": 0, "details": []}
         for correction in self.get_successful_corrections():
             test_file = correction.get("test_file")
             if not test_file:
@@ -208,19 +229,23 @@ def get_correction_tracker() -> CorrectionTracker:
 
 
 def record_correction(
-    original_by: str, original_value: str, corrected_by: str, corrected_value: str, success: bool = True
-):
+    original_by: str,
+    original_value: str,
+    corrected_by: str,
+    corrected_value: str,
+    success: bool = True
+) -> None:
     """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]:
+def apply_corrections_to_test_files() -> ApplyCorrectionsResult:
     """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"):
+def export_corrections_report(output_file: str = "selector_corrections.json") -> None:
     """Export corrections report to JSON file."""
     get_correction_tracker().export_corrections_report(output_file)

{selenium_selector_autocorrect-0.1.0 → selenium_selector_autocorrect-0.1.1}/src/selenium_selector_autocorrect/wait_hook.py

@@ -2,9 +2,10 @@
 
 import logging
 import time
-from typing import Callable, Optional
+from typing import Any, Callable, Optional, Tuple, TypeVar, Union, cast
 
 from selenium.common.exceptions import TimeoutException
+from selenium.webdriver.remote.webdriver import WebDriver
 from selenium.webdriver.remote.webelement import WebElement
 from selenium.webdriver.support.wait import WebDriverWait
 
@@ -13,19 +14,41 @@ from .correction_tracker import record_correction
 
 logger = logging.getLogger(__name__)
 
-_original_until = WebDriverWait.until
+T = TypeVar("T")
+DriverType = Union[WebDriver, WebElement]
 
+_original_until: Callable[..., Any] = WebDriverWait.until
 
-def _patched_until(self, method: Callable, message: str = ""):
+
+def _patched_until(self: WebDriverWait, method: Callable[[WebDriver], T], message: str = "") -> T:
     """Patched until method with auto-correct support."""
-    screen = None
-    stacktrace = None
+    screen: Optional[str] = None
+    stacktrace: Optional[str] = None
 
     end_time = time.monotonic() + self._timeout
     while True:
         try:
             value = method(self._driver)
             if value:
+                # Check if we should suggest a better selector for the found element
+                auto_correct = get_auto_correct()
+                if auto_correct.suggest_better_selectors and isinstance(value, WebElement):
+                    locator = _extract_locator_from_method(method)
+                    if locator:
+                        by, value_str = locator
+                        suggest_driver: WebDriver
+                        if isinstance(self._driver, WebElement):
+                            suggest_driver = self._driver.parent  # type: ignore[attr-defined]
+                        else:
+                            suggest_driver = self._driver
+                        
+                        better_suggestion = auto_correct.suggest_better_selector(
+                            suggest_driver, by, value_str, value
+                        )
+                        if better_suggestion:
+                            better_by, better_value = better_suggestion
+                            logger.info(f"[AUTO-SUGGEST] Found element with {by}='{value_str[:50]}...'")
+                            logger.info(f"[AUTO-SUGGEST] Suggested better selector: {better_by}='{better_value}'")
                 return value
         except self._ignored_exceptions as exc:
             screen = getattr(exc, "screen", None)
@@ -43,9 +66,11 @@ def _patched_until(self, method: Callable, message: str = ""):
                 f"[AUTO-CORRECT] Timeout waiting for element {by}='{value_str[:80]}...' - attempting auto-correction"
             )
 
-            driver = self._driver
-            if isinstance(driver, WebElement):
-                driver = driver.parent
+            driver: WebDriver
+            if isinstance(self._driver, WebElement):
+                driver = self._driver.parent  # type: ignore[attr-defined]
+            else:
+                driver = self._driver
 
             suggestion = auto_correct.suggest_selector(
                 driver,
@@ -71,35 +96,41 @@ def _patched_until(self, method: Callable, message: str = ""):
                                 corrected_value=suggested_value,
                                 success=True,
                             )
-                            return result
+                            return cast(T, 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]:
+def _extract_locator_from_method(method: Callable[..., Any]) -> Optional[Tuple[str, str]]:
     """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
+            locator: Tuple[str, str] = method.locator
+            logger.debug(f"[AUTO-CORRECT] Found locator attribute: {locator}")
+            return 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):
+                    first, second = cell_contents
+                    if isinstance(first, str) and isinstance(second, str):
                         logger.debug(f"[AUTO-CORRECT] Extracted locator from closure: {cell_contents}")
-                        return cell_contents
+                        return (first, second)
         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]:
+def _create_corrected_method(
+    original_method: Callable[..., Any],
+    new_by: str,
+    new_value: str
+) -> Optional[Callable[[WebDriver], Any]]:
     """Create a new expected condition method with corrected locator."""
     try:
         from selenium.webdriver.support import expected_conditions as EC
@@ -128,13 +159,13 @@ def _create_corrected_method(original_method: Callable, new_by: str, new_value:
         return None
 
 
-def install_auto_correct_hook():
+def install_auto_correct_hook() -> None:
     """Install the auto-correct hook into WebDriverWait."""
-    WebDriverWait.until = _patched_until
+    WebDriverWait.until = _patched_until  # type: ignore[method-assign,assignment]
     logger.info("[AUTO-CORRECT] Hook installed into WebDriverWait")
 
 
-def uninstall_auto_correct_hook():
+def uninstall_auto_correct_hook() -> None:
     """Remove the auto-correct hook from WebDriverWait."""
-    WebDriverWait.until = _original_until
+    WebDriverWait.until = _original_until  # type: ignore[method-assign]
     logger.info("[AUTO-CORRECT] Hook removed from WebDriverWait")

{selenium_selector_autocorrect-0.1.0 → selenium_selector_autocorrect-0.1.1/src/selenium_selector_autocorrect.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: selenium-selector-autocorrect
-Version: 0.1.0
+Version: 0.1.1
 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>

{selenium_selector_autocorrect-0.1.0 → selenium_selector_autocorrect-0.1.1}/src/selenium_selector_autocorrect.egg-info/SOURCES.txt

@@ -5,7 +5,6 @@ src/selenium_selector_autocorrect/__init__.py
 src/selenium_selector_autocorrect/ai_providers.py
 src/selenium_selector_autocorrect/auto_correct.py
 src/selenium_selector_autocorrect/correction_tracker.py
-src/selenium_selector_autocorrect/py.typed
 src/selenium_selector_autocorrect/wait_hook.py
 src/selenium_selector_autocorrect.egg-info/PKG-INFO
 src/selenium_selector_autocorrect.egg-info/SOURCES.txt

selenium_selector_autocorrect-0.1.0/src/selenium_selector_autocorrect/py.typed

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