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

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.2"
 
 from .ai_providers import AIProvider, LocalAIProvider, configure_provider, get_provider
 from .auto_correct import (

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,22 +40,32 @@ 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:
             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
-            )
+            url = f"{self.base_url}/v1/chat/completions"
+            payload = {"messages": [{"role": "user", "content": "test"}], "max_tokens": 1}
+            
+            logger.debug(f"[AI-REQUEST] POST {url}")
+            logger.debug(f"[AI-REQUEST] Payload: {payload}")
+            
+            response = requests.post(url, json=payload, timeout=30)
+            
+            logger.debug(f"[AI-RESPONSE] Status: {response.status_code}")
+            logger.debug(f"[AI-RESPONSE] Headers: {dict(response.headers)}")
+            logger.debug(f"[AI-RESPONSE] Body length: {len(response.text)} chars")
+            if response.text:
+                logger.debug(f"[AI-RESPONSE] Body preview: {response.text[:500]}")
+            
             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}")
+            logger.debug(f"[AI-ERROR] Exception details: {type(e).__name__}: {str(e)}")
             self._available = False
         return self._available
     
@@ -70,22 +80,37 @@ class LocalAIProvider(AIProvider):
             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
-            )
+            url = f"{self.base_url}/v1/chat/completions"
+            payload = {
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                "temperature": 0.3,
+                "max_tokens": 500
+            }
+            
+            logger.debug(f"[AI-REQUEST] POST {url}")
+            logger.debug(f"[AI-REQUEST] System prompt ({len(system_prompt)} chars): {system_prompt[:200]}...")
+            logger.debug(f"[AI-REQUEST] User prompt ({len(user_prompt)} chars): {user_prompt[:200]}...")
+            logger.debug(f"[AI-REQUEST] Full payload: {payload}")
+            
+            response = requests.post(url, json=payload, timeout=30)
+            
+            logger.debug(f"[AI-RESPONSE] Status: {response.status_code}")
+            logger.debug(f"[AI-RESPONSE] Headers: {dict(response.headers)}")
+            logger.debug(f"[AI-RESPONSE] Body length: {len(response.text)} chars")
+            logger.debug(f"[AI-RESPONSE] Full body: {response.text[:2000]}")
+            
             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", "")
+            logger.debug(f"[AI-PARSED] Content length: {len(content) if content else 0} chars")
+            logger.debug(f"[AI-PARSED] Content preview: {content[:500] if content else 'None'}")
+            return content
         except requests.exceptions.HTTPError as e:
+            logger.error(f"[AI-ERROR] HTTP Error {e.response.status_code}")
+            logger.error(f"[AI-ERROR] Response body: {e.response.text[:1000]}")
             if e.response.status_code == 503:
                 logger.info(f"Local AI service unavailable (503). Disabling auto-correction.")
                 self._available = False
@@ -93,7 +118,8 @@ class LocalAIProvider(AIProvider):
                 logger.warning(f"Local AI HTTP error: {e}")
             return None
         except Exception as e:
-            logger.warning(f"Local AI request failed: {e}")
+            logger.error(f"[AI-ERROR] Request failed: {type(e).__name__}: {str(e)}")
+            logger.debug(f"[AI-ERROR] Exception details: {e}", exc_info=True)
             self._available = False
             return None
 
@@ -110,7 +136,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 +146,4 @@ def configure_provider(provider: AIProvider):
     _provider_instance = provider
 
 
-_provider_instance = None
+_provider_instance: Optional[AIProvider] = None

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