alita-sdk 0.3.161__py3-none-any.whl → 0.3.163__py3-none-any.whl

alita_sdk/tools/carrier/update_ui_test_schedule_tool.py

@@ -0,0 +1,278 @@
+import logging
+import json
+import traceback
+import re
+from typing import Type
+from langchain_core.tools import BaseTool, ToolException
+from pydantic.fields import Field
+from pydantic import create_model, BaseModel
+from .api_wrapper import CarrierAPIWrapper
+
+
+logger = logging.getLogger(__name__)
+
+
+class UpdateUITestScheduleTool(BaseTool):
+    api_wrapper: CarrierAPIWrapper = Field(..., description="Carrier API Wrapper instance")
+    name: str = "update_ui_test_schedule"
+    description: str = ("Update UI test schedule on the Carrier platform. Use this tool when user wants to update, modify, or change a UI test schedule. "
+                        "Provide test_id, schedule_name, and cron_timer, or leave empty to see available tests.")
+    args_schema: Type[BaseModel] = create_model(
+        "UpdateUITestScheduleInput",
+        test_id=(str, Field(default="", description="Test ID to update schedule for")),
+        schedule_name=(str, Field(default="", description="Name for the new schedule")),
+        cron_timer=(str, Field(default="", description="Cron expression for schedule timing (e.g., '0 2 * * *')")),
+    )
+    
+    def _run(self, test_id: str = "", schedule_name: str = "", cron_timer: str = ""):
+        try:
+            # Check if no parameters provided - show available tests
+            if (not test_id or test_id.strip() == "") and (not schedule_name or schedule_name.strip() == "") and (not cron_timer or cron_timer.strip() == ""):
+                return self._show_available_tests_and_instructions()
+            
+            # Check if test_id is missing but other params provided
+            if (not test_id or test_id.strip() == ""):
+                return self._show_missing_test_id_message()
+            
+            # Check if schedule_name or cron_timer is missing
+            if (not schedule_name or schedule_name.strip() == "") or (not cron_timer or cron_timer.strip() == ""):
+                return self._show_missing_parameters_message(test_id, schedule_name, cron_timer)
+            
+            # Validate cron timer format
+            if not self._validate_cron_timer(cron_timer):
+                return self._show_invalid_cron_message(cron_timer)
+            
+            # Get UI tests list to verify test exists
+            ui_tests = self.api_wrapper.get_ui_tests_list()
+            test_data = None
+            test_id_int = None
+            
+            # Try to find test by ID
+            if test_id.isdigit():
+                test_id_int = int(test_id)
+                for test in ui_tests:
+                    if test.get("id") == test_id_int:
+                        test_data = test
+                        break
+            
+            if not test_data:
+                available_tests = []
+                for test in ui_tests:
+                    available_tests.append(f"ID: {test.get('id')}, Name: {test.get('name')}")
+                
+                return f"❌ **Test not found for ID: {test_id}**\n\n**Available UI tests:**\n" + "\n".join([f"- {test}" for test in available_tests])
+            
+            # Get detailed test configuration
+            test_details = self.api_wrapper.get_ui_test_details(str(test_id_int))
+            
+            if not test_details:
+                return f"❌ **Could not retrieve test details for test ID {test_id_int}.**"
+            
+            # Parse and update the test configuration
+            updated_config = self._parse_and_update_test_data(test_details, schedule_name, cron_timer)
+            
+            # Execute the PUT request to update the test
+            result = self.api_wrapper.update_ui_test(str(test_id_int), updated_config)
+            
+            return self._format_success_message(test_data.get('name', 'Unknown'), test_id_int, schedule_name, cron_timer)
+            
+        except Exception:
+            stacktrace = traceback.format_exc()
+            logger.error(f"Error updating UI test schedule: {stacktrace}")
+            raise ToolException(stacktrace)
+    
+    def _show_available_tests_and_instructions(self):
+        """Show available tests and instructions when no parameters provided."""
+        try:
+            ui_tests = self.api_wrapper.get_ui_tests_list()
+            
+            if not ui_tests:
+                return "❌ **No UI tests found.**"
+            
+            message = ["# 📋 Update UI Test Schedule\n"]
+            message.append("## Available UI Tests:")
+            
+            for test in ui_tests:
+                message.append(f"- **ID: {test.get('id')}**, Name: `{test.get('name')}`, Runner: `{test.get('runner')}`")
+            
+            message.append("\n## 📝 Instructions:")
+            message.append("For updating UI test schedule, please provide me:")
+            message.append("- **`test_id`** - The ID of the test you want to update")
+            message.append("- **`schedule_name`** - A name for your new schedule")
+            message.append("- **`cron_timer`** - Cron expression for timing (e.g., `0 2 * * *` for daily at 2 AM)")
+            
+            message.append("\n## 💡 Example:")
+            message.append("```")
+            message.append("test_id: 42")
+            message.append("schedule_name: Daily Morning Test")
+            message.append("cron_timer: 0 2 * * *")
+            message.append("```")
+            
+            return "\n".join(message)
+            
+        except Exception:
+            stacktrace = traceback.format_exc()
+            logger.error(f"Error fetching UI tests list: {stacktrace}")
+            raise ToolException(stacktrace)
+    
+    def _show_missing_test_id_message(self):
+        """Show message when test_id is missing."""
+        return """# ❌ Missing Test ID
+
+**For updating UI test schedule, please provide me:**
+- **`test_id`** - The ID of the test you want to update  
+- **`schedule_name`** - A name for your new schedule
+- **`cron_timer`** - Cron expression for timing
+
+Use the tool without parameters to see available tests."""
+    
+    def _show_missing_parameters_message(self, test_id: str, schedule_name: str, cron_timer: str):
+        """Show message when some parameters are missing."""
+        missing = []
+        if not schedule_name or schedule_name.strip() == "":
+            missing.append("**`schedule_name`**")
+        if not cron_timer or cron_timer.strip() == "":
+            missing.append("**`cron_timer`**")
+        
+        message = [f"# ❌ Missing Parameters for Test ID: {test_id}\n"]
+        message.append("**Missing parameters:**")
+        for param in missing:
+            message.append(f"- {param}")
+        
+        message.append("\n**For updating UI test schedule, please provide:**")
+        message.append("- **`test_id`** ✅ (provided)")
+        message.append("- **`schedule_name`** - A name for your new schedule")
+        message.append("- **`cron_timer`** - Cron expression for timing (e.g., `0 2 * * *`)")
+        
+        return "\n".join(message)
+    
+    def _validate_cron_timer(self, cron_timer: str) -> bool:
+        """Validate cron timer format."""
+        # Basic cron validation - should have 5 parts separated by spaces
+        parts = cron_timer.strip().split()
+        if len(parts) != 5:
+            return False
+        
+        # Each part should contain only digits, *, /, -, or ,
+        cron_pattern = re.compile(r'^[0-9*,/-]+$')
+        return all(cron_pattern.match(part) for part in parts)
+    
+    def _show_invalid_cron_message(self, cron_timer: str):
+        """Show message for invalid cron timer."""
+        return f"""# ❌ Invalid Cron Timer Format
+
+**Provided:** `{cron_timer}`
+
+**Cron format should be:** `minute hour day month weekday`
+
+## Valid Examples:
+- `0 2 * * *` - Daily at 2:00 AM
+- `30 14 * * 1` - Every Monday at 2:30 PM  
+- `0 */6 * * *` - Every 6 hours
+- `15 10 1 * *` - First day of every month at 10:15 AM
+- `0 9 * * 1-5` - Weekdays at 9:00 AM
+
+## Format Rules:
+- **Minute:** 0-59
+- **Hour:** 0-23
+- **Day:** 1-31
+- **Month:** 1-12
+- **Weekday:** 0-7 (0 and 7 are Sunday)
+- Use **`*`** for "any value"
+- Use **`,`** for multiple values
+- Use **`-`** for ranges
+- Use **`/`** for step values"""
+    
+    def _parse_and_update_test_data(self, get_data: dict, schedule_name: str, cron_timer: str) -> dict:
+        """Parse GET response data and transform it into the required format for PUT request."""
+        
+        # Extract environment and test type from test parameters
+        env_type = ""
+        test_type = ""
+        for param in get_data.get("test_parameters", []):
+            if param.get("name") == "env_type":
+                env_type = param.get("default", "")
+            elif param.get("name") == "test_type":
+                test_type = param.get("default", "")
+        
+        # Construct common_params from GET data
+        common_params = {
+            "aggregation": get_data.get("aggregation", "max"),
+            "cc_env_vars": get_data.get("cc_env_vars", {}),
+            "entrypoint": get_data.get("entrypoint", ""),
+            "env_type": env_type,
+            "env_vars": get_data.get("env_vars", {}),
+            "location": get_data.get("location", ""),
+            "loops": get_data.get("loops", 1),
+            "name": get_data.get("name", ""),
+            "parallel_runners": get_data.get("parallel_runners", 1),
+            "runner": get_data.get("runner", ""),
+            "source": get_data.get("source", {}),
+            "test_type": test_type
+        }
+        
+        # Extract only required integrations (reporters and system)
+        integrations = {
+            "reporters": get_data.get("integrations", {}).get("reporters", {}),
+            "system": get_data.get("integrations", {}).get("system", {})
+        }
+        
+        # Process existing schedules and add the new one
+        schedules = []
+        
+        # Keep existing schedules
+        for schedule in get_data.get("schedules", []):
+            existing_schedule = {
+                "active": schedule.get("active", False),
+                "cron": schedule.get("cron", ""),
+                "cron_radio": "custom",
+                "errors": {},
+                "id": schedule.get("id"),
+                "name": schedule.get("name", ""),
+                "project_id": schedule.get("project_id"),
+                "rpc_kwargs": schedule.get("rpc_kwargs"),
+                "test_id": schedule.get("test_id"),
+                "test_params": schedule.get("test_params", [])
+            }
+            schedules.append(existing_schedule)
+        
+        # Add the new schedule
+        new_schedule = {
+            "active": True,
+            "cron": cron_timer,
+            "cron_radio": "custom",
+            "errors": {},
+            "id": None,  # New schedule, no ID yet
+            "name": schedule_name,
+            "test_params": []
+        }
+        schedules.append(new_schedule)
+        
+        # Assemble the final PUT request data
+        put_data = {
+            "common_params": common_params,
+            "integrations": integrations,
+            "run_test": False,
+            "schedules": schedules,
+            "test_parameters": []  # Empty as required in PUT request
+        }
+        
+        return put_data
+    
+    def _format_success_message(self, test_name: str, test_id: int, schedule_name: str, cron_timer: str) -> str:
+        """Format success message in markdown."""
+        return f"""# ✅ UI Test Schedule Updated Successfully!
+
+## Test Information:
+- **Test Name:** `{test_name}`
+- **Test ID:** `{test_id}`
+
+## New Schedule Added:
+- **Schedule Name:** `{schedule_name}`
+- **Cron Timer:** `{cron_timer}`
+- **Status:** Active ✅
+
+## 🎯 What happens next:
+The test will now run automatically according to the specified schedule. You can view and manage schedules in the Carrier platform UI.
+
+**Schedule will execute:** Based on cron expression `{cron_timer}`"""

alita_sdk/tools/github/__init__.py

@@ -23,6 +23,7 @@ def _get_toolkit(tool) -> BaseToolkit:
         github_app_id=tool['settings'].get('app_id', None),
         github_app_private_key=tool['settings'].get('app_private_key', None),
         llm=tool['settings'].get('llm', None),
+        alita=tool['settings'].get('alita', None),
         connection_string=tool['settings'].get('connection_string', None),
         collection_name=str(tool['id']),
         doctype='code',

alita_sdk/tools/github/api_wrapper.py

@@ -51,7 +51,9 @@ class AlitaGitHubAPIWrapper(BaseCodeToolApiWrapper):
 
     # Add LLM instance
     llm: Optional[Any] = None
-
+    # Alita instance
+    alita: Optional[Any] = None
+    
     # Vector store configuration
     connection_string: Optional[SecretStr] = None
     collection_name: Optional[str] = None
@@ -109,7 +111,7 @@ class AlitaGitHubAPIWrapper(BaseCodeToolApiWrapper):
         )
 
         # Initialize GitHub client with keyword arguments
-        github_client = GitHubClient(auth_config=auth_config, repo_config=repo_config)
+        github_client = GitHubClient(auth_config=auth_config, repo_config=repo_config, alita=values.get("alita"))
         # Initialize GraphQL client with keyword argument
         graphql_client = GraphQLClientWrapper(github_graphql_instance=github_client.github_api._Github__requester)
         # Set client attributes on the class (renamed from _github_client to github_client_instance)

alita_sdk/tools/github/github_client.py

@@ -34,10 +34,11 @@ from .schemas import (
     SearchIssues,
     CreateIssue,
     UpdateIssue,
-    LoaderSchema,
     GetCommits,
     GetCommitChanges,
+    GetCommitsDiff,
     ApplyGitPatch,
+    ApplyGitPatchFromArtifact,
     TriggerWorkflow,
     GetWorkflowStatus,
     GetWorkflowLogs,
@@ -91,6 +92,9 @@ class GitHubClient(BaseModel):
     # Adding auth config and repo config as optional fields for initialization
     auth_config: Optional[GitHubAuthConfig] = Field(default=None, exclude=True)
     repo_config: Optional[GitHubRepoConfig] = Field(default=None, exclude=True)
+    
+    # Alita instance
+    alita: Optional[Any] = Field(default=None, exclude=True)
 
     @model_validator(mode='before')
     def initialize_github_client(cls, values):
@@ -388,6 +392,111 @@ class GitHubClient(BaseModel):
         except Exception as e:
             # Return error as JSON instead of plain text
             return {"error": str(e), "message": f"Unable to retrieve commit changes due to error: {str(e)}"}
+        
+    def get_commits_diff(self, base_sha: str, head_sha: str, repo_name: Optional[str] = None) -> str:
+        """
+        Retrieves the diff between two commits.
+
+        Parameters:
+            base_sha (str): The base commit SHA to compare from.
+            head_sha (str): The head commit SHA to compare to.
+            repo_name (Optional[str]): Name of the repository in format 'owner/repo'.
+
+        Returns:
+            str: A detailed diff comparison between the two commits or an error message.
+        """
+        try:
+            # Get the repository
+            repo = self.github_api.get_repo(repo_name) if repo_name else self.github_repo_instance
+            
+            # Get the comparison between the two commits
+            comparison = repo.compare(base_sha, head_sha)
+            
+            # Extract comparison information
+            diff_info = {
+                "base_commit": {
+                    "sha": comparison.base_commit.sha,
+                    "message": comparison.base_commit.commit.message,
+                    "author": comparison.base_commit.commit.author.name,
+                    "date": comparison.base_commit.commit.author.date.isoformat()
+                },
+                "head_commit": {
+                    "sha": comparison.head_commit.sha,
+                    "message": comparison.head_commit.commit.message,
+                    "author": comparison.head_commit.commit.author.name,
+                    "date": comparison.head_commit.commit.author.date.isoformat()
+                },
+                "status": comparison.status,  # ahead, behind, identical, or diverged
+                "ahead_by": comparison.ahead_by,
+                "behind_by": comparison.behind_by,
+                "total_commits": comparison.total_commits,
+                "commits": [],
+                "files": []
+            }
+            
+            # Get commits in the comparison
+            for commit in comparison.commits:
+                commit_info = {
+                    "sha": commit.sha,
+                    "message": commit.commit.message,
+                    "author": commit.commit.author.name,
+                    "date": commit.commit.author.date.isoformat(),
+                    "url": commit.html_url
+                }
+                diff_info["commits"].append(commit_info)
+            
+            # Get changed files information
+            for file in comparison.files:
+                file_info = {
+                    "filename": file.filename,
+                    "status": file.status,  # added, modified, removed, renamed
+                    "additions": file.additions,
+                    "deletions": file.deletions,
+                    "changes": file.changes,
+                    "patch": file.patch if hasattr(file, 'patch') and file.patch else None,
+                    "blob_url": file.blob_url if hasattr(file, 'blob_url') else None,
+                    "raw_url": file.raw_url if hasattr(file, 'raw_url') else None
+                }
+                
+                # Add previous filename for renamed files
+                if file.status == "renamed" and hasattr(file, 'previous_filename'):
+                    file_info["previous_filename"] = file.previous_filename
+                    
+                diff_info["files"].append(file_info)
+            
+            # Add summary statistics
+            diff_info["summary"] = {
+                "total_files_changed": len(diff_info["files"]),
+                "total_additions": sum(f["additions"] for f in diff_info["files"]),
+                "total_deletions": sum(f["deletions"] for f in diff_info["files"])
+            }
+            
+            return diff_info
+
+        except Exception as e:
+            # Return error as JSON instead of plain text
+            return {"error": str(e), "message": f"Unable to retrieve diff between commits due to error: {str(e)}"}
+        
+    def apply_git_patch_from_file(self, bucket_name: str, file_name: str, commit_message: Optional[str] = "Apply git patch", repo_name: Optional[str] = None) -> str:
+        """Applies a git patch from a file stored in a specified bucket.
+
+        Args:
+            bucket_name (str): The name of the bucket where the patch file is stored.
+            file_name (str): The name of the patch file to apply.
+            commit_message (Optional[str], optional): The commit message for the patch application. Defaults to "Apply git patch".
+            repo_name (Optional[str], optional): The name of the repository to apply the patch to. Defaults to None.
+
+        Returns:
+            str: A summary of the applied changes or an error message.
+        """
+        try:
+            patch_content = self.alita.download_artifact(bucket_name, file_name)
+            if not patch_content or not isinstance(patch_content, str):
+                return {"error": "Patch file not found", "message": f"Patch file '{file_name}' not found in bucket '{bucket_name}'."}
+            # Apply the git patch using the content
+            return self.apply_git_patch(patch_content, commit_message, repo_name)
+        except Exception as e:
+            return {"error": str(e), "message": f"Unable to download patch file: {str(e)}"}
 
     def apply_git_patch(self, patch_content: str, commit_message: Optional[str] = "Apply git patch", repo_name: Optional[str] = None) -> str:
         """
@@ -1902,6 +2011,13 @@ class GitHubClient(BaseModel):
                 "description": self.get_commit_changes.__doc__,
                 "args_schema": GetCommitChanges,
             },
+            {
+                "ref": self.get_commits_diff,
+                "name": "get_commits_diff",
+                "mode": "get_commits_diff",
+                "description": self.get_commits_diff.__doc__,
+                "args_schema": GetCommitsDiff,
+            },
             {
                 "ref": self.apply_git_patch,
                 "name": "apply_git_patch",
@@ -1909,6 +2025,13 @@ class GitHubClient(BaseModel):
                 "description": self.apply_git_patch.__doc__,
                 "args_schema": ApplyGitPatch,
             },
+            {
+                "ref": self.apply_git_patch_from_file,
+                "name": "apply_git_patch_from_file",
+                "mode": "apply_git_patch_from_file",
+                "description": self.apply_git_patch_from_file.__doc__,
+                "args_schema": ApplyGitPatchFromArtifact,
+            },
             {
                 "ref": self.trigger_workflow,
                 "name": "trigger_workflow",

alita_sdk/tools/github/schemas.py

@@ -159,6 +159,13 @@ GetCommitChanges = create_model(
     repo_name=(Optional[str], Field(default=None, description="Name of the repository (e.g., 'owner/repo'). If None, uses the default repository."))
 )
 
+GetCommitsDiff = create_model(
+    "GetCommitsDiff",
+    base_sha=(str, Field(description="The base commit SHA to compare from")),
+    head_sha=(str, Field(description="The head commit SHA to compare to")),
+    repo_name=(Optional[str], Field(default=None, description="Name of the repository (e.g., 'owner/repo'). If None, uses the default repository."))
+)
+
 ApplyGitPatch = create_model(
     "ApplyGitPatch",
     patch_content=(str, Field(description="The git patch content in unified diff format")),
@@ -166,6 +173,14 @@ ApplyGitPatch = create_model(
     repo_name=(Optional[str], Field(default=None, description="Name of the repository (e.g., 'owner/repo'). If None, uses the default repository."))
 )
 
+ApplyGitPatchFromArtifact = create_model(
+    "ApplyGitPatchFromArtifact",
+    bucket_name=(str, Field(description="Name of the artifact bucket containing the patch file")),
+    file_name=(str, Field(description="Name of the patch file to download and apply")),
+    commit_message=(Optional[str], Field(description="Commit message for the patch application", default="Apply git patch from artifact")),
+    repo_name=(Optional[str], Field(default=None, description="Name of the repository (e.g., 'owner/repo'). If None, uses the default repository."))
+)
+
 TriggerWorkflow = create_model(
     "TriggerWorkflow",
     workflow_id=(str, Field(description="The ID or file name of the workflow to trigger (e.g., 'build.yml', '1234567')")),

alita_sdk/tools/zephyr_squad/__init__.py

@@ -0,0 +1,62 @@
+from typing import List, Literal, Optional
+
+from langchain_community.agent_toolkits.base import BaseToolkit
+from langchain_core.tools import BaseTool
+from pydantic import create_model, BaseModel, Field, SecretStr
+
+from .api_wrapper import ZephyrSquadApiWrapper
+from ..base.tool import BaseAction
+from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+
+name = "zephyr"
+
+def get_tools(tool):
+    return ZephyrSquadToolkit().get_toolkit(
+        selected_tools=tool['settings'].get('selected_tools', []),
+        account_id=tool['settings']["account_id"],
+        access_key=tool['settings']["access_key"],
+        secret_key=tool['settings']["secret_key"],
+        toolkit_name=tool.get('toolkit_name')
+    ).get_tools()
+
+class ZephyrSquadToolkit(BaseToolkit):
+    tools: List[BaseTool] = []
+    toolkit_max_length: int = 0
+
+    @staticmethod
+    def toolkit_config_schema() -> BaseModel:
+        selected_tools = {x['name']: x['args_schema'].schema() for x in ZephyrSquadApiWrapper.model_construct().get_available_tools()}
+        ZephyrSquadToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
+        return create_model(
+            "zephyr_squad",
+            account_id=(str, Field(description="AccountID for the user that is going to be authenticating")),
+            access_key=(str, Field(description="Generated access key")),
+            secret_key=(SecretStr, Field(description="Generated secret key")),
+            selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
+            __config__={'json_schema_extra': {'metadata': {"label": "Zephyr Squad", "icon_url": "zephyr.svg",
+                            "categories": ["test management"],
+                            "extra_categories": ["test automation", "test case management", "test planning"]
+                        }}}
+        )
+
+    @classmethod
+    def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
+        zephyr_api_wrapper = ZephyrSquadApiWrapper(**kwargs)
+        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
+        available_tools = zephyr_api_wrapper.get_available_tools()
+        tools = []
+        for tool in available_tools:
+            if selected_tools:
+                if tool["name"] not in selected_tools:
+                    continue
+            tools.append(BaseAction(
+                api_wrapper=zephyr_api_wrapper,
+                name=prefix + tool["name"],
+                description=tool["description"],
+                args_schema=tool["args_schema"]
+            ))
+        return cls(tools=tools)
+
+    def get_tools(self):
+        return self.tools
+