alita-sdk 0.3.160__tar.gz → 0.3.162__tar.gz

{alita_sdk-0.3.160 → alita_sdk-0.3.162}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.160
+Version: 0.3.162
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.160 → alita_sdk-0.3.162}/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-0.3.160 → alita_sdk-0.3.162}/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-0.3.160 → alita_sdk-0.3.162}/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-0.3.160 → alita_sdk-0.3.162}/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-0.3.160 → alita_sdk-0.3.162}/alita_sdk/tools/postman/api_wrapper.py

@@ -1370,33 +1370,30 @@ class PostmanApiWrapper(BaseToolApiWrapper):
     def update_request_tests(self, request_path: str, tests: str, **kwargs) -> str:
         """Update request test scripts."""
         try:
-            # Get the request ID
-            _, request_id, _ = self._get_request_item_and_id(request_path)
-            
-            # Get current request to preserve existing data
-            current_request = self._make_request('GET', f'/collections/{self.collection_id}/requests/{request_id}')
-            request_data = current_request.get("data", {})
+            # Get request item and ID
+            request_item, request_id, _ = self._get_request_item_and_id(request_path)
             
-            # Prepare the events array - preserve any non-test events
-            events = [event for event in request_data.get("events", []) if event.get("listen") != "test"]
+            # Get existing events and preserve non-test events
+            existing_events = request_item.get("event", [])
+            events = [event for event in existing_events if event.get("listen") != "test"]
             
-            # Add the new test script
+            # Add the new test script using the official API format
             events.append({
                 "listen": "test",
                 "script": {
-                    "type": "text/javascript",
-                    "exec": tests.strip().split('\n')
+                    "exec": tests.strip().split('\n'),
+                    "type": "text/javascript"
                 }
             })
             
-            # Update the events array in the request data
-            request_data["events"] = events
-            
-            # Update the request using the individual request endpoint
+            # Create update payload using the events array format from official spec
+            request_update = {
+                "events": events
+            }
+
+            # Update using the individual request endpoint with proper events format
             response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
-                                        json=request_data)
-            
-            logger.info(f"Test script updated successfully for request '{request_path}'")
+                                          json=request_update)
             return json.dumps({"success": True, "message": f"Request '{request_path}' tests updated successfully"}, indent=2)
         except Exception as e:
             stacktrace = format_exc()
@@ -1407,33 +1404,30 @@ class PostmanApiWrapper(BaseToolApiWrapper):
     def update_request_pre_script(self, request_path: str, pre_request_script: str, **kwargs) -> str:
         """Update request pre-request scripts."""
         try:
-            # Get the request ID
-            _, request_id, _ = self._get_request_item_and_id(request_path)
-            
-            # Get current request to preserve existing data
-            current_request = self._make_request('GET', f'/collections/{self.collection_id}/requests/{request_id}')
-            request_data = current_request.get("data", {})
+            # Get request item and ID
+            request_item, request_id, _ = self._get_request_item_and_id(request_path)
             
-            # Prepare the events array - preserve any non-prerequest events
-            events = [event for event in request_data.get("events", []) if event.get("listen") != "prerequest"]
+            # Get existing events and preserve non-prerequest events
+            existing_events = request_item.get("event", [])
+            events = [event for event in existing_events if event.get("listen") != "prerequest"]
             
-            # Add the new prerequest script
+            # Add the new prerequest script using the official API format
             events.append({
                 "listen": "prerequest",
                 "script": {
-                    "type": "text/javascript",
-                    "exec": pre_request_script.strip().split('\n')
+                    "exec": pre_request_script.strip().split('\n'),
+                    "type": "text/javascript"
                 }
             })
             
-            # Update the events array in the request data
-            request_data["events"] = events
-            
-            # Update the request using the individual request endpoint
+            # Create update payload using the events array format from official spec
+            request_update = {
+                "events": events
+            }
+
+            # Update using the individual request endpoint with proper events format
             response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
-                                        json=request_data)
-            
-            logger.info(f"Pre-request script updated successfully for request '{request_path}'")
+                                          json=request_update)
             return json.dumps({"success": True, "message": f"Request '{request_path}' pre-script updated successfully"}, indent=2)
         except Exception as e:
             stacktrace = format_exc()
@@ -1612,16 +1606,14 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             The script content as JSON string, or an error message if the script doesn't exist
         """
         try:
-            # Get the request ID and fetch current request data
-            _, request_id, _ = self._get_request_item_and_id(request_path)
-            
-            # Get current request to have the latest version with updated scripts
-            current_request = self._make_request('GET', f'/collections/{self.collection_id}/requests/{request_id}')
-            request_data = current_request.get("data", {})
+            # Get the request item from the collection and also try individual endpoint
+            request_item, request_id, _ = self._get_request_item_and_id(request_path)
             
-            # Find the script by type
             script_content = None
-            for event in request_data.get("events", []):
+            
+            # Method 1: Check events array (modern format)
+            events = request_item.get("event", [])
+            for event in events:
                 if event.get("listen") == script_type:
                     script = event.get("script", {})
                     exec_content = script.get("exec", [])
@@ -1631,13 +1623,25 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                         script_content = str(exec_content)
                     break
             
+            # Method 2: If not found in events, try individual request endpoint for direct fields
             if script_content is None:
+                try:
+                    individual_request = self._make_request('GET', f'/collections/{self.collection_id}/requests/{request_id}')
+                    if script_type == "test":
+                        script_content = individual_request.get("tests", "")
+                    elif script_type == "prerequest":
+                        script_content = individual_request.get("preRequestScript", "")
+                except:
+                    # If individual endpoint fails, that's okay, we'll fall back to not found
+                    pass
+            
+            if not script_content or script_content.strip() == "":
                 return json.dumps({"success": False, "message": f"No {script_type} script found for request '{request_path}'"}, indent=2)
             
             return json.dumps({
                 "success": True,
                 "script_type": script_type, 
-                "script_content": script_content, 
+                "script_content": script_content.strip(), 
                 "request_path": request_path
             }, indent=2)
                 

{alita_sdk-0.3.160 → alita_sdk-0.3.162}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.160
+Version: 0.3.162
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.160 → alita_sdk-0.3.162}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alita_sdk"
-version = "0.3.160"
+version = "0.3.162"
 description = "SDK for building langchain agents using resources from Alita"
 readme = "README.md"
 requires-python = ">=3.10"