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

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.dist-info → selenium_selector_autocorrect-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: selenium-selector-autocorrect
-Version: 0.1.0
+Version: 0.1.2
 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>
@@ -75,22 +75,6 @@ element = WebDriverWait(driver, 10).until(
 )
 ```
 
-## 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:
@@ -124,67 +108,28 @@ install_auto_correct_hook()
 
 ```python
 from selenium_selector_autocorrect import (
-    install_auto_correct_hook,
     get_auto_correct,
     get_correction_tracker,
-    export_corrections_report
+    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:
+## AI Service Setup
 
-```bash
-POST http://localhost:8765/v1/chat/completions
-```
+This package requires a local AI service with an OpenAI-compatible API. The following endpoints are used:
 
-For file auto-updates:
-```bash
-POST http://localhost:8765/v1/workspace/files/read
-POST http://localhost:8765/v1/workspace/files/edit
-## Correction Reports
+- `POST {LOCAL_AI_API_URL}/v1/chat/completions` — chat completions for suggestions
+- `POST {LOCAL_AI_API_URL}/v1/workspace/files/read` — read file content
+- `POST {LOCAL_AI_API_URL}/v1/workspace/files/edit` — apply edits to files
+- `POST {LOCAL_AI_API_URL}/v1/workspace/files/search` — search workspace
 
-Export correction reports in JSON format:
+## Exporting Reports
 
 ```python
 from selenium_selector_autocorrect import export_corrections_report
@@ -193,6 +138,7 @@ export_corrections_report("corrections_report.json")
 ```
 
 Report format:
+
 ```json
 {
   "corrections": [
@@ -215,13 +161,13 @@ Report format:
 }
 ```
 
-## Best Practices
+## Troubleshooting
+
+**AI service not available**: Ensure the local AI service is running and reachable via `LOCAL_AI_API_URL`.
 
-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
+**Auto-update not running**: Verify `SELENIUM_AUTO_UPDATE_TESTS` is set to `"1"`.
+
+**Selector strings not found when updating**: Check quote styles in your source files match those used in the correction.
 
 ## Requirements
 
@@ -231,47 +177,45 @@ Report format:
 
 ## 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
+MIT
 
-When contributing:
-1. Follow PEP 8 style guidelines
-2. Add tests for new features
-3. Update documentation
-4. No emojis in code or documentation
+## Contributing
 
-## Troubleshooting
+Please follow PEP 8, add tests for new features, and update documentation when changing behavior.
 
-### AI Service Not Available
+See [CHANGELOG.md](CHANGELOG.md) for release notes and version history.
 
-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
+## Publishing to PyPI
 
-**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)
+Create a PyPI API token at https://pypi.org/manage/account/#api-tokens (recommended scope: project or account) and keep the token secret. PyPI no longer accepts username/password uploads — use the token as the password and `__token__` as the username.
 
-### No Corrections Happening
-Solution: Ensure your local AI service is running on the configured port.
+PowerShell (Windows) example:
 
-### Test File Not Updated
+```powershell
+$env:TWINE_USERNAME='__token__'
+$env:TWINE_PASSWORD='pypi-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+.\venv\Scripts\python.exe -m pip install --upgrade build twine
+.\venv\Scripts\python.exe -m build
+.\venv\Scripts\python.exe -m twine upload dist/*
+```
 
-Possible causes:
-- `SELENIUM_AUTO_UPDATE_TESTS` not set to "1"
-- Test file path not detected correctly
-- Selector string not found in source file
+Unix / macOS example:
 
-### No Corrections Happening
+```bash
+export TWINE_USERNAME='__token__'
+export TWINE_PASSWORD='pypi-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+python3 -m pip install --upgrade build twine
+python3 -m build
+python3 -m twine upload dist/*
+```
+
+To publish to TestPyPI (verify release first):
+
+```bash
+python3 -m twine upload --repository-url https://test.pypi.org/legacy/ dist/*
+```
 
-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.
+Notes:
+- Use an API token (not account password). If using a CI system, store the token in secure secrets.
+- You can add a persistent `~/.pypirc` for repeated uploads; see PyPI documentation for details.
+- If upload fails with a 403, verify the token is correct and has the required scope.

selenium_selector_autocorrect-0.1.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+selenium_selector_autocorrect/__init__.py,sha256=aP02rJbuJxwqMDuc1Y-LoNA3AMYeoCe0_0q_xYNKnTE,1665
+selenium_selector_autocorrect/ai_providers.py,sha256=MIsnwIgTSQQxL4uex4f_4l886EvGLLXvojbheyMgjuI,5966
+selenium_selector_autocorrect/auto_correct.py,sha256=ME2dxkN4liNC797x1nFn-HAKvyXxl7q2ePv5SNon42w,11335
+selenium_selector_autocorrect/correction_tracker.py,sha256=VXmu-9Qgcknl6DOuIuawG_LQJNr3B_N0eHQDghygQEk,32927
+selenium_selector_autocorrect/wait_hook.py,sha256=Vs1FRtKG73i1Cphgf4a3_P5MTdlrWdeOnmzG1ewnlS4,7659
+selenium_selector_autocorrect-0.1.2.dist-info/licenses/LICENSE,sha256=VRPy6YXF2wA_3MeTDnpa_-6Zgjt8c2C0D_iIyhDkduc,1095
+selenium_selector_autocorrect-0.1.2.dist-info/METADATA,sha256=Oh8ha_xAm2MGYGx_lguQ2_citrtVBoaLSM83u236qGk,7318
+selenium_selector_autocorrect-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+selenium_selector_autocorrect-0.1.2.dist-info/top_level.txt,sha256=nQ78Mk-XHDhYBckP0tMZvoFAZmZGO4Ec4-e1i61Fdz0,30
+selenium_selector_autocorrect-0.1.2.dist-info/RECORD,,

selenium_selector_autocorrect/py.typed

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

selenium_selector_autocorrect-0.1.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-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,,