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

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

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

@@ -0,0 +1,181 @@
+# 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"))
+)
+```
+
+## 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 (
+    get_auto_correct,
+    get_correction_tracker,
+    export_corrections_report,
+)
+
+auto_correct = get_auto_correct()
+auto_correct.enabled = True
+
+tracker = get_correction_tracker()
+export_corrections_report("corrections_report.json")
+```
+
+## AI Service Setup
+
+This package requires a local AI service with an OpenAI-compatible API. The following endpoints are used:
+
+- `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
+
+## Exporting Reports
+
+```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"
+  }
+}
+```
+
+## Troubleshooting
+
+**AI service not available**: Ensure the local AI service is running and reachable via `LOCAL_AI_API_URL`.
+
+**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
+
+- Python >= 3.8
+- selenium >= 4.0.0
+- requests >= 2.25.0
+
+## License
+
+MIT
+
+## Contributing
+
+Please follow PEP 8, add tests for new features, and update documentation when changing behavior.
+
+See [CHANGELOG.md](CHANGELOG.md) for release notes and version history.
+
+## Publishing to PyPI
+
+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.
+
+PowerShell (Windows) example:
+
+```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/*
+```
+
+Unix / macOS example:
+
+```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/*
+```
+
+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.1 → selenium_selector_autocorrect-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "selenium-selector-autocorrect"
-version = "0.1.1"
+version = "0.1.2"
 description = "Automatic Selenium selector correction using AI when elements fail to be found"
 readme = "README.md"
 requires-python = ">=3.8"

{selenium_selector_autocorrect-0.1.1 → selenium_selector_autocorrect-0.1.2}/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__ = "0.1.1"
+__version__ = "0.1.2"
 
 from .ai_providers import AIProvider, LocalAIProvider, configure_provider, get_provider
 from .auto_correct import (

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

@@ -48,14 +48,24 @@ class LocalAIProvider(AIProvider):
         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,23 +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: 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
@@ -94,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