alita-sdk 0.3.130__py3-none-any.whl → 0.3.132__py3-none-any.whl

alita_sdk/clients/client.py

@@ -8,6 +8,7 @@ from langchain_core.messages import (
     AIMessage, HumanMessage,
     SystemMessage, BaseMessage,
 )
+from langchain_core.tools import ToolException
 
 from ..langchain.assistant import Assistant as LangChainAssistant
 # from ..llamaindex.assistant import Assistant as LLamaAssistant
@@ -174,7 +175,12 @@ class AlitaClient:
             tools = []
         if chat_history is None:
             chat_history = []
-        data = self.get_app_version_details(application_id, application_version_id)
+        try:
+            data = self.get_app_version_details(application_id, application_version_id)
+        except ApiDetailsRequestError as e:
+            error_msg = f"Failed to fetch application version details for {application_id}/{application_version_id}\nDetails: {e}"
+            logger.error(error_msg)
+            raise ToolException(error_msg)
 
         if application_variables:
             for var in data.get('variables', {}):

alita_sdk/community/analysis/ado_analyse/__init__.py

@@ -0,0 +1,100 @@
+from typing import List, Optional, Literal
+from elitea_analyse.ado.azure_search import AzureSearch
+from pydantic import SecretStr, create_model, BaseModel, ConfigDict, Field
+
+from langchain_core.tools import BaseTool, BaseToolkit
+
+from alita_tools.utils import get_max_toolkit_length
+from alita_tools.base.tool import BaseAction
+
+from ....tools.artifact import ArtifactWrapper
+from .api_wrapper import AdoAnalyseWrapper
+
+from ...utils import check_schema
+
+
+name = "Analyse_Ado"
+
+
+class AnalyseAdo(BaseToolkit):
+    tools: List[BaseTool] = []
+    toolkit_max_length: int = 0
+
+    @staticmethod
+    def toolkit_config_schema() -> type[BaseModel]:
+        selected_tools = {
+            x["name"]: x["args_schema"].schema()
+            for x in AdoAnalyseWrapper.model_construct().get_available_tools()
+        }
+        AnalyseAdo.toolkit_max_length = get_max_toolkit_length(selected_tools)
+
+        return create_model(
+            "analyse_ado",
+            organization=(str, Field(description="Azure DevOps organization name",
+                json_schema_extra={"toolkit_name": True, "max_toolkit_length": AnalyseAdo.toolkit_max_length})),
+            username=(str, Field(description="Azure DevOps username (e.g., 'john.doe@domain.com')")),
+            token=(SecretStr, Field(description="Azure DevOps Access Token", json_schema_extra={"secret": True})),
+            project_keys=(Optional[str], Field(description="Azure DevOps project keys separated by comma", default=None)),
+            default_branch_name=(Optional[str], Field(description="Default branch name", default="main")),
+            area=(Optional[str], Field(description="Area path filter", default="")),
+            artifact_bucket_path=(Optional[str], Field(description="Artifact Bucket Path", default="analyse-ado")),
+            selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={"args_schemas": selected_tools})),
+            __config__=ConfigDict(json_schema_extra={"metadata": {
+                    "label": "Analyse_Ado",
+                    "icon_url": "ado-icon.svg", # ???
+                    "hidden": True,
+                    "sections": {
+                        "auth": {
+                            "required": True,
+                            "subsections": [{"name": "Token", "fields": ["token"]}],
+                        }
+                    },
+                }
+            })
+        )
+
+    @classmethod
+    def get_toolkit(cls, client: "AlitaClient", selected_tools: list[str], **kwargs):
+
+        bucket_path = kwargs.get("artifact_bucket_path") or "analyse-ado"
+        artifact_wrapper = ArtifactWrapper(client=client, bucket=bucket_path)
+        check_schema(artifact_wrapper)
+
+        project_keys = kwargs.get("project_keys") or ""
+        area = kwargs.get("area", "")
+
+        organization = kwargs.get("organization")
+        username = kwargs.get("username")
+        token = kwargs.get("token")
+
+        if not organization or not username or not token:
+            raise ValueError("Organization, username, and token must be provided.")
+
+        ado_search = AzureSearch(organization=organization, user=username, token=token)
+
+        ado_analyse_wrapper = AdoAnalyseWrapper(
+            artifacts_wrapper=artifact_wrapper,
+            project_keys=project_keys,
+            default_branch_name=kwargs.get("default_branch_name", "main"),
+            area=area,
+            ado_search=ado_search,
+        )
+
+        selected_tools = selected_tools or []
+        available_tools = ado_analyse_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=ado_analyse_wrapper,
+                    name=tool["name"],
+                    description=tool["description"],
+                    args_schema=tool["args_schema"],
+                )
+            )
+
+        return cls(tools=tools)

alita_sdk/community/analysis/ado_analyse/api_wrapper.py

@@ -0,0 +1,259 @@
+import logging
+
+from typing import Optional, Dict, Any
+from langchain_core.callbacks import dispatch_custom_event
+from pydantic import BaseModel, Field
+
+from elitea_analyse.utils.constants import OUTPUT_WORK_ITEMS_FILE
+from elitea_analyse.ado.azure_search import AzureSearch
+from elitea_analyse.ado.main import (
+    OUTPUT_WORK_ITEMS,
+    get_work_items_several_projects,
+    get_commits_several_projects,
+    get_merge_requests_several_projects,
+    get_pipelines_runs_several_projects,
+)
+
+
+from alita_tools.elitea_base import BaseToolApiWrapper
+
+from src.alita_sdk.utils.save_dataframe import save_dataframe_to_artifact
+from ....tools.artifact import ArtifactWrapper
+from ....utils.logging import with_streamlit_logs
+
+
+logger = logging.getLogger(__name__)
+
+
+class GetAdoWorkItemsArgs(BaseModel):
+    resolved_after: str = Field(description="Resolveed after date (i.e. 2023-01-01)")
+    updated_after: str = Field(description="Updated after date (i.e. 2023-01-01)")
+    created_after: str = Field(description="Created after date (i.e. 2023-01-01)")
+    area: Optional[str] = Field(description="Area path filter.", default="")
+    project_keys: Optional[str] = Field(
+        description="One or more projects keys separated with comma.", default=""
+    )
+
+
+class AdoCommitsArgs(BaseModel):
+    project_keys: Optional[str] = Field(
+        description="One or more projects keys separated with comma.", default=""
+    )
+    since_date: str = Field(description="Get commits after this date 'YYYY-MM-DD'")
+
+
+class AdoPipelinesArgs(BaseModel):
+    project_keys: Optional[str] = Field(
+        description="One or more projects keys separated with comma.", default=""
+    )
+
+
+class AdoAnalyseWrapper(BaseToolApiWrapper):
+    artifacts_wrapper: ArtifactWrapper
+    project_keys: str  # Comma-separated list of Azure DevOps project names
+    default_branch_name: str = "main"
+    area: str = ""
+    ado_search: AzureSearch  # Azure DevOps search client
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def get_projects_list(self):
+        """
+        Get all projects in the organization that the authenticated user has access to.
+        Details on a page: https://docs.microsoft.com/en-us/rest/api/azure/devops/core/projects/list
+        """
+        result = self.ado_search.get_projects_list()
+
+        save_dataframe_to_artifact(
+            self.artifacts_wrapper,
+            result,
+            "projects_info.csv",
+            csv_options={"index": False},
+        )
+
+        return (
+            f"You have access to {len(result)} project. "
+            f"Data has been downloaded to the bucket as 'projects_info_AzureDevOps.csv'."
+        )
+
+    @with_streamlit_logs(tool_name="get_work_items")
+    def get_work_items(
+        self,
+        resolved_after: str,
+        updated_after: str,
+        created_after: str,
+        area: str = "",
+        project_keys: Optional[str] = None,
+    ) -> str:
+        """
+        Get work items from multiple Azure DevOps projects.
+
+            project_keys: str
+                Comma-separated project names.
+            resolved_after: str
+                Date filter for resolved items 'YYYY-MM-DD'.
+            updated_after: str
+                Date filter for updated items 'YYYY-MM-DD'.
+            created_after: str
+                Date filter for created items 'YYYY-MM-DD'.
+            area: str
+                Area path filter (optional).
+        """
+        project_keys = project_keys or self.project_keys
+        area = area or self.area
+
+        df_work_items = get_work_items_several_projects(
+            project_keys,
+            resolved_after,
+            updated_after,
+            created_after,
+            area=area,
+            ado_search=self.ado_search,
+        )
+
+        save_dataframe_to_artifact(
+            self.artifacts_wrapper,
+            df_work_items,
+            f"{OUTPUT_WORK_ITEMS_FILE}{project_keys}.csv",
+            csv_options={"index_label": "id"},
+        )
+
+        return (
+            f"Work items for {project_keys} have been successfully retrieved "
+            f"and saved to the bucket as '{OUTPUT_WORK_ITEMS}{project_keys}.csv'."
+        )
+
+    async def get_commits(
+        self,
+        since_date: str,
+        project_keys: Optional[str] = None,
+        new_version: bool = True,
+        with_commit_size: bool = True,
+    ) -> str:
+        """
+        Get commits from multiple Azure DevOps projects.
+
+        since_date: str
+            Get commits after this date 'YYYY-MM-DD'.
+        project_keys: str
+            Comma-separated project names.
+        new_version: bool
+            Use new API version.
+        with_commit_size: bool
+            Include commit size info.
+        """
+        project_keys = project_keys or self.project_keys
+
+        # Await the coroutine to get commits
+        df_commits = await get_commits_several_projects(
+            project_keys,
+            since_date,
+            new_version=new_version,
+            with_commit_size=with_commit_size,
+            ado_search=self.ado_search,
+        )
+
+        save_dataframe_to_artifact(
+            self.artifacts_wrapper,
+            df_commits,
+            f"commits_details_{project_keys}.csv",
+            csv_options={"index_label": "id"},
+        )
+
+        return (
+            f"Commits for {project_keys} have been successfully retrieved "
+            f"and saved to the bucket as 'commits_details_{project_keys}.csv'."
+        )
+
+    def get_merge_requests(
+        self, since_date: str, project_keys: Optional[str] = None
+    ) -> str:
+        """
+        Get pull requests from multiple Azure DevOps projects.
+
+        project_keys: str
+            Comma-separated project names.
+        since_date: str
+            Get PRs after this date 'YYYY-MM-DD'.
+        """
+        project_keys = project_keys or self.project_keys
+
+        df_prs = get_merge_requests_several_projects(
+            project_keys, since_date, ado_search=self.ado_search
+        )
+
+        save_dataframe_to_artifact(
+            self.artifacts_wrapper,
+            df_prs,
+            f"merge_requests_details_{project_keys}.csv",
+            csv_options={"index": False},
+        )
+
+        return (
+            f"Pull requests for {project_keys} have been successfully retrieved "
+            f"and saved to the bucket as 'merge_requests_details_{project_keys}.csv'."
+        )
+
+    def get_pipelines_runs(
+        self,
+        project_keys: Optional[str] = None,
+    ) -> str:
+        """
+        Get pipeline runs from multiple Azure DevOps projects.
+
+        project_keys: str
+            Comma-separated project names.
+        """
+        project_keys = project_keys or self.project_keys
+        pipelines_df = get_pipelines_runs_several_projects(project_keys, ado_search=self.ado_search)
+
+        save_dataframe_to_artifact(
+            self.artifacts_wrapper, pipelines_df, f"pipelines_runs_{project_keys}.csv", csv_options={"index": False}
+         )
+
+        return (
+            f"Pipeline runs for {project_keys} have been successfully retrieved "
+            f"and saved to the bucket as 'pipelines_runs_{project_keys}.csv'."
+        )
+
+    def get_available_tools(self) -> list[Dict[str, Any]]:
+        """Get a list of available tools."""
+        return [
+            {
+                "name": "get_projects_list",
+                "description": self.get_projects_list.__doc__,
+                "ref": self.get_projects_list,
+                "args_schema": {},
+            },
+            {
+                "name": "get_work_items",
+                "description": self.get_work_items.__doc__,
+                "ref": self.get_work_items,
+                "args_schema": GetAdoWorkItemsArgs,
+            },
+            {
+                "name": "get_commits",
+                "description": self.get_commits.__doc__,
+                "ref": self.get_commits,
+                "args_schema": AdoCommitsArgs,
+            },
+            {
+                "name": "get_merge_requests",
+                "description": self.get_merge_requests.__doc__,
+                "ref": self.get_merge_requests,
+                "args_schema": AdoCommitsArgs,
+            },
+            {
+                "name": "get_pipelines_runs",
+                "description": self.get_pipelines_runs.__doc__,
+                "ref": self.get_pipelines_runs,
+                "args_schema": AdoPipelinesArgs,
+            },
+        ]
+
+    def run(self, mode: str, *args: Any, **kwargs: Any):
+        for tool in self.get_available_tools():
+            if tool["name"] == mode:
+                return tool["ref"](*args, **kwargs)
+        raise ValueError(f"Unknown mode: {mode}")

alita_sdk/community/analysis/github_analyse/__init__.py

@@ -0,0 +1,94 @@
+from typing import List, Optional, Literal
+from pydantic import SecretStr, create_model, BaseModel, ConfigDict, Field
+
+from langchain_core.tools import BaseTool, BaseToolkit
+
+from elitea_analyse.github.github_org import GitHubGetOrgLvl
+from alita_tools.utils import get_max_toolkit_length
+from alita_tools.base.tool import BaseAction
+
+from ....tools.artifact import ArtifactWrapper
+from .api_wrapper import GitHubAnalyseWrapper
+
+from ...utils import check_schema
+
+
+name = "Analyse_Github"
+
+
+class AnalyseGithub(BaseToolkit):
+    tools: List[BaseTool] = []
+    toolkit_max_length: int = 0
+
+    @staticmethod
+    def toolkit_config_schema() -> type[BaseModel]:
+        selected_tools = {
+            x["name"]: x["args_schema"].schema()
+            for x in GitHubAnalyseWrapper.model_construct().get_available_tools()
+        }
+        AnalyseGithub.toolkit_max_length = get_max_toolkit_length(selected_tools)
+
+        return create_model(
+            "analyse_github",  
+            owner=(str, Field(description="GitHub owner name",
+                json_schema_extra={"toolkit_name": True, "max_toolkit_length": AnalyseGithub.toolkit_max_length})),
+            token=(SecretStr, Field(description="Github Access Token", json_schema_extra={"secret": True})),
+            repos=(Optional[str],
+                Field(description="Comma-separated list of GitHub repository names e.g. 'repo1,repo2'", default=None)),
+            artifact_bucket_path=(Optional[str],
+                                  Field(description="Artifact Bucket Path", default="analyse-github")),
+            selected_tools=(
+                List[Literal[tuple(selected_tools)]], Field(default=[],
+                json_schema_extra={"args_schemas": selected_tools})
+            ),
+            __config__=ConfigDict(json_schema_extra={"metadata": {
+                    "label": "Analyse_Github",
+                    "icon_url": None, # ?? is exists
+                    "hidden": True,
+                    "sections": {
+                        "auth": {
+                            "required": True,
+                            "subsections": [{"name": "Token", "fields": ["token"]}],
+                        }
+                    },
+                }
+            })
+        )
+
+    @classmethod
+    def get_toolkit(cls, client: "AlitaClient", selected_tools: list[str], **kwargs):
+        bucket_path = kwargs.get("artifact_bucket_path") or "analyse-github"
+        artifact_wrapper = ArtifactWrapper(client=client, bucket=bucket_path)
+        check_schema(artifact_wrapper)
+
+        owner = kwargs.get("owner")
+        token = kwargs.get("token")
+
+        if not owner or not token:
+            raise ValueError("GitHub owner and token must be provided.")
+
+        git = GitHubGetOrgLvl(owner=owner, token=token)
+
+        github_analyse_wrapper = GitHubAnalyseWrapper(
+            artifacts_wrapper=artifact_wrapper,
+            repos=kwargs.get("repos") or "",
+            git=git
+        )
+
+        selected_tools = selected_tools or []
+        available_tools = github_analyse_wrapper.get_available_tools()
+
+        tools = []
+        for tool in available_tools:
+            if selected_tools and tool["name"] not in selected_tools:
+                continue
+            tools.append(
+                BaseAction(
+                    api_wrapper=github_analyse_wrapper,
+                    name=tool["name"],
+                    description=tool["description"],
+                    args_schema=tool["args_schema"],
+                )
+            )
+
+        return cls(tools=tools)

alita_sdk/community/analysis/github_analyse/api_wrapper.py

@@ -0,0 +1,166 @@
+import logging
+from typing import Optional, Any
+from langchain_core.callbacks import dispatch_custom_event
+from pydantic import BaseModel, Field
+
+from elitea_analyse.github.github_org import GitHubGetOrgLvl
+from elitea_analyse.github.main_github import (
+   extract_commits_from_multiple_repos,
+   extract_pull_requests_from_multiple_repos,
+   extract_repositories_list,
+   extract_repositories_extended_data,
+)
+
+from alita_tools.elitea_base import BaseToolApiWrapper
+from src.alita_sdk.utils.save_dataframe import save_dataframe_to_artifact
+from ....tools.artifact import ArtifactWrapper
+from ....utils.logging import with_streamlit_logs
+
+
+logger = logging.getLogger(__name__)
+
+
+class GetGithubCommitsFromReposArgs(BaseModel):
+    since_after: str = Field( description="Date to filter commits from, in 'YYYY-MM-DD' format." )
+    repos: Optional[str] = Field(
+        description="Comma-separated list of repositories to extract commits from.",
+        default="",
+    )
+
+
+class GetGithubRepositoriesListArgs(BaseModel):
+    pushed_after: str = Field( description="Date to filter repositories by, in 'YYYY-MM-DD' format." )
+
+
+class GitHubAnalyseWrapper(BaseToolApiWrapper):
+    artifacts_wrapper: ArtifactWrapper
+    repos: str  # Comma-separated list of GitHub repository names e.g. 'repo1,repo2'
+    git: GitHubGetOrgLvl  # GitHub client
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def get_commits_from_repos(self, since_after: str, repos: Optional[str] = None) -> str:
+        """
+        Extracts commit data from multiple GitHub repositories since the specified date. Saves the result to a CSV file.
+
+        repos : str
+            The string containing repositories names to extract data from, separated by commas.
+        since_date : str
+            The date to start extracting commits from, in 'YYYY-MM-DD' format.
+        """
+        repos = repos or self.repos
+        df_commits = extract_commits_from_multiple_repos(repos, since_after, git=self.git)
+
+        if df_commits is None or df_commits.empty:
+            return f"No commits found for repositories: {repos} since {since_after}"
+
+        output_filename = f"commits_{repos.replace(',', '_')}.csv"
+        save_dataframe_to_artifact( self.artifacts_wrapper, df_commits, output_filename, {"index": False} )
+
+        return f"GitHub commits data for {repos} saved to {output_filename}"
+
+    def get_pull_requests_from_repos(self, since_after: str, repos: Optional[str] = None) -> str:
+        """
+        Extracts pull request data from multiple GitHub repositories since the specified date. 
+        Saves the result to a CSV file.
+
+        repos: str
+            The string containing repositories names to extract data from, separated by commas.
+        since_date: str
+            The date to start extracting pull requests from, in 'YYYY-MM-DD' format.
+        """
+        repos = repos or self.repos
+        df_pull_requests = extract_pull_requests_from_multiple_repos(repos, since_after, git=self.git)
+
+        output_filename = f"pull_requests_details_{repos.replace(',', '_')}.csv"
+        save_dataframe_to_artifact( self.artifacts_wrapper, df_pull_requests, output_filename, {"index": False} )
+
+        return f"GitHub pull requests data saved to {output_filename}"
+
+    def get_repositories_list(self, pushed_after: str) -> str:
+        """
+        Extracts a list of GitHub repositories that were pushed after the specified date. 
+        Saves the result to a CSV file.
+
+        pushed_after : str
+            The date to filter repositories by, in 'YYYY-MM-DD' format.
+        """
+        df_repos = extract_repositories_list(pushed_after, git=self.git)
+
+        output_filename = "github_repos_list.csv"
+        save_dataframe_to_artifact( self.artifacts_wrapper, df_repos, output_filename, {"index": False} )
+        dispatch_custom_event(
+            "thinking_step",
+            data={
+                "message": f"Extracted {len(df_repos)} repositories pushed after {pushed_after}.",
+                "tool_name": "github_repositories_list_extraction",
+                "toolkit": "analyse_github",
+            },
+        )
+
+        return f"GitHub repositories list saved to {output_filename}"
+
+    @with_streamlit_logs(tool_name="get_github_repositories_extended_data")
+    def get_repositories_extended_data(self, pushed_after: str) -> str:
+        """
+        Extracts extended information about GitHub repositories that were pushed after the specified date. 
+        Saves the result to a CSV file.
+
+        pushed_after : str
+            The date to filter repositories by, in 'YYYY-MM-DD' format.
+        """
+        df_repos_extended = extract_repositories_extended_data(pushed_after, git=self.git)
+
+        output_filename = "github_repos_extended_info.csv"
+        save_dataframe_to_artifact( self.artifacts_wrapper, df_repos_extended, output_filename, {"index": False} )
+
+        dispatch_custom_event(
+            "thinking_step",
+            data={
+                "message": (
+                    f"Extracted extended data for {len(df_repos_extended)} repositories "
+                    f"pushed after {pushed_after}."
+                ),
+                "tool_name": "github_repositories_extended_data_extraction",
+                "toolkit": "analyse_github",
+            },
+        )
+
+        return f"Extended repository info that you have access saved to {output_filename}"
+
+    def get_available_tools(self):
+        """Get a list of available tools."""
+        return [
+            {
+                "name": "get_commits_from_repos",
+                "description": self.get_commits_from_repos.__doc__,
+                "args_schema": GetGithubCommitsFromReposArgs,
+                "ref": self.get_commits_from_repos,
+            },
+            {
+                "name": "get_pull_requests_from_repos",
+                "description": self.get_pull_requests_from_repos.__doc__,
+                "args_schema": GetGithubCommitsFromReposArgs,
+                "ref": self.get_pull_requests_from_repos,
+            },
+            {
+                "name": "get_repositories_list",
+                "description": self.get_repositories_list.__doc__,
+                "args_schema": GetGithubRepositoriesListArgs,
+                "ref": self.get_repositories_list,
+            },
+            {
+                "name": "get_repositories_extended_data",
+                "description": self.get_repositories_extended_data.__doc__,
+                "args_schema": GetGithubRepositoriesListArgs,
+                "ref": self.get_repositories_extended_data,
+            },
+        ]
+
+    def run(self, mode: str, *args: Any, **kwargs: Any):
+        for tool in self.get_available_tools():
+            if tool["name"] == mode:
+                return tool["ref"](*args, **kwargs)
+
+        raise ValueError(f"Unknown mode: {mode}")