alita-sdk 0.3.257__py3-none-any.whl → 0.3.584__py3-none-any.whl

alita_sdk/configurations/xray.py

@@ -7,7 +7,7 @@ class XrayConfiguration(BaseModel):
     model_config = ConfigDict(
         json_schema_extra={
             "metadata": {
-                "label": "Xray",
+                "label": "Xray Cloud",
                 "icon_url": "xray.svg",
                 "sections": {
                     "auth": {
@@ -30,3 +30,96 @@ class XrayConfiguration(BaseModel):
     base_url: str = Field(description="Xray URL")
     client_id: Optional[str] = Field(description="Client ID")
     client_secret: Optional[SecretStr] = Field(description="Client secret")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Xray Cloud.
+        
+        Args:
+            settings: Dictionary containing Xray configuration
+                - base_url: Xray Cloud URL (required)
+                - client_id: OAuth2 Client ID (required)
+                - client_secret: OAuth2 Client Secret (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Validate base_url
+        base_url = settings.get("base_url", "").strip()
+        if not base_url:
+            return "Xray URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        base_url = base_url.rstrip("/")
+        
+        # Basic URL validation
+        if not base_url.startswith(("http://", "https://")):
+            return "Xray URL must start with http:// or https://"
+        
+        # Validate client_id
+        client_id = settings.get("client_id", "").strip() if settings.get("client_id") else ""
+        if not client_id:
+            return "Xray client ID is required"
+        
+        # Validate client_secret
+        client_secret = settings.get("client_secret")
+        if not client_secret:
+            return "Xray client secret is required"
+        
+        # Extract client_secret value if it's a SecretStr
+        client_secret_value = client_secret.get_secret_value() if hasattr(client_secret, 'get_secret_value') else client_secret
+        
+        if not client_secret_value or not str(client_secret_value).strip():
+            return "Xray client secret cannot be empty"
+        
+        # Test connection using /api/v2/authenticate endpoint
+        # This is the OAuth2 token generation endpoint for Xray Cloud
+        auth_url = f"{base_url}/api/v2/authenticate"
+        
+        auth_payload = {
+            "client_id": client_id,
+            "client_secret": str(client_secret_value).strip()
+        }
+        
+        try:
+            response = requests.post(
+                auth_url,
+                json=auth_payload,
+                headers={"Content-Type": "application/json"},
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully authenticated and got token
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid client ID or secret"
+            elif response.status_code == 403:
+                return "Access forbidden: check client credentials"
+            elif response.status_code == 400:
+                # Bad request - could be invalid format
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error", "Bad request")
+                    return f"Bad request: {error_msg}"
+                except:
+                    return "Bad request: check client ID and secret format"
+            elif response.status_code == 404:
+                return "Xray API endpoint not found: verify the Xray URL"
+            else:
+                return f"Xray API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Xray at {base_url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Xray at {base_url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Xray: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/zephyr_enterprise.py

@@ -10,7 +10,7 @@ class ZephyrEnterpriseConfiguration(BaseModel):
                 "label": "Zephyr Enterprise",
                 "icon_url": "zephyr.svg",
                 "section": "credentials",
-                "type": "zephyr-enterprise",
+                "type": "zephyr_enterprise",
                 "categories": ["test management"],
                 "extra_categories": ["zephyr", "test automation", "test case management", "test planning"],
             }
@@ -18,3 +18,96 @@ class ZephyrEnterpriseConfiguration(BaseModel):
     )
     base_url: str = Field(description="Zephyr base URL")
     token: Optional[SecretStr] = Field(description="API token")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Zephyr Enterprise.
+        
+        Args:
+            settings: Dictionary containing Zephyr Enterprise configuration
+                - base_url: Zephyr Enterprise instance URL (required)
+                - token: API token for authentication (optional, anonymous access possible)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Validate base_url
+        base_url = settings.get("base_url", "").strip()
+        if not base_url:
+            return "Zephyr Enterprise URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        base_url = base_url.rstrip("/")
+        
+        # Basic URL validation
+        if not base_url.startswith(("http://", "https://")):
+            return "Zephyr Enterprise URL must start with http:// or https://"
+        
+        # Get token (optional)
+        token = settings.get("token")
+        
+        # Prepare headers
+        headers = {}
+        has_token = False
+        if token:
+            # Extract token value if it's a SecretStr
+            token_value = token.get_secret_value() if hasattr(token, 'get_secret_value') else token
+            if token_value and str(token_value).strip():
+                headers["Authorization"] = f"Bearer {str(token_value).strip()}"
+                has_token = True
+        
+        # Use different endpoints based on whether authentication is provided
+        # Note: /healthcheck may allow anonymous access, so we use authenticated endpoints when token is provided
+        if has_token:
+            # Test with an endpoint that requires authentication: /flex/services/rest/latest/project
+            # This endpoint lists projects and requires proper authentication
+            test_url = f"{base_url}/flex/services/rest/latest/user/current"
+        else:
+            # Without token, test basic connectivity with healthcheck
+            test_url = f"{base_url}/flex/services/rest/latest/healthcheck"
+        
+        try:
+            response = requests.get(
+                test_url,
+                headers=headers,
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected
+                return None
+            elif response.status_code == 401:
+                if has_token:
+                    return "Authentication failed: invalid API token"
+                else:
+                    return "Authentication required: provide API token"
+            elif response.status_code == 403:
+                return "Access forbidden: check token permissions"
+            elif response.status_code == 404:
+                # If user endpoint not found, try healthcheck as fallback
+                if has_token:
+                    try:
+                        fallback_url = f"{base_url}/flex/services/rest/latest/healthcheck"
+                        fallback_response = requests.get(fallback_url, headers=headers, timeout=10)
+                        if fallback_response.status_code == 200:
+                            return None
+                    except:
+                        pass
+                return "Zephyr Enterprise API endpoint not found: verify the Zephyr URL"
+            else:
+                return f"Zephyr Enterprise API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Zephyr Enterprise at {base_url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Zephyr Enterprise at {base_url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Zephyr Enterprise: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/zephyr_essential.py

@@ -0,0 +1,95 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class ZephyrEssentialConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Zephyr Essential",
+                "icon_url": "zephyr.svg",
+                "section": "credentials",
+                "type": "zephyr_essential",
+                "categories": ["test management"],
+                "extra_categories": ["zephyr", "test automation", "test case management", "test planning"],
+            }
+        }
+    )
+    base_url: Optional[str] = Field(description="Zephyr Essential API Base URL", default=None)
+    token: SecretStr = Field(description="Zephyr Essential API Token")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Zephyr Essential (Zephyr Scale).
+        
+        Args:
+            settings: Dictionary containing Zephyr Essential configuration
+                - base_url: Zephyr Essential API Base URL (optional, defaults to Zephyr Scale Cloud API)
+                - token: Zephyr Essential API Token (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Get base_url or use default
+        base_url = settings.get("base_url")
+        if base_url:
+            base_url = base_url.strip().rstrip("/")
+            # Validate URL format if provided
+            if not base_url.startswith(("http://", "https://")):
+                return "Zephyr Essential URL must start with http:// or https://"
+        else:
+            # Default to Zephyr Scale Cloud API
+            base_url = "https://api.zephyrscale.smartbear.com/v2"
+        
+        # Validate token
+        token = settings.get("token")
+        if not token:
+            return "Zephyr Essential API token is required"
+        
+        # Extract token value if it's a SecretStr
+        token_value = token.get_secret_value() if hasattr(token, 'get_secret_value') else token
+        
+        if not token_value or not str(token_value).strip():
+            return "Zephyr Essential API token cannot be empty"
+        
+        # Test connection using /projects endpoint (requires authentication)
+        test_url = f"{base_url}/projects"
+        
+        headers = {
+            "Authorization": f"Bearer {str(token_value).strip()}"
+        }
+        
+        try:
+            response = requests.get(
+                test_url,
+                headers=headers,
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected and authenticated
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid API token"
+            elif response.status_code == 403:
+                return "Access forbidden: token lacks required permissions"
+            elif response.status_code == 404:
+                return "Zephyr Essential API endpoint not found: verify the API URL"
+            else:
+                return f"Zephyr Essential API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Zephyr Essential at {base_url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Zephyr Essential at {base_url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Zephyr Essential: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/runtime/clients/artifact.py

@@ -4,7 +4,7 @@ from json import dumps
 import chardet
 import logging
 
-from alita_sdk.tools.utils.content_parser import parse_file_content
+from ...tools.utils.content_parser import parse_file_content
 
 logger = logging.getLogger(__name__)
 
@@ -38,11 +38,21 @@ class Artifact:
         if len(data) == 0:
             # empty file might be created
             return ""
-        if isinstance(data, dict) and data['error']:
-            return f"{data['error']}. {data['content'] if data['content'] else ''}"
+        if isinstance(data, dict) and data.get('error'):
+            return f"{data['error']}. {data.get('content', '')}"
         detected = chardet.detect(data)
         if detected['encoding'] is not None:
-            return data.decode(detected['encoding'])
+            try:
+                return data.decode(detected['encoding'])
+            except Exception:
+                logger.error("Error while default encoding")
+                return parse_file_content(file_name=artifact_name,
+                                          file_content=data,
+                                          is_capture_image=is_capture_image,
+                                          page_number=page_number,
+                                          sheet_name=sheet_name,
+                                          excel_by_sheets=excel_by_sheets,
+                                          llm=llm)
         else:
             return parse_file_content(file_name=artifact_name,
                                   file_content=data,
@@ -77,4 +87,11 @@ class Artifact:
         if not bucket_name:
             bucket_name = self.bucket_name
         return self.create(artifact_name, new_data, bucket_name)
+    
+    def get_content_bytes(self,
+            artifact_name: str,
+            bucket_name: str = None):
+        if not bucket_name:
+            bucket_name = self.bucket_name
+        return self.client.download_artifact(bucket_name, artifact_name)