alita-sdk 0.3.129__py3-none-any.whl → 0.3.131__py3-none-any.whl

alita_sdk/community/analysis/gitlab_analyse/__init__.py

@@ -0,0 +1,107 @@
+from typing import List, Optional, Literal
+from elitea_analyse.git.git_search import GitLabV4Search
+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 GitLabAnalyseWrapper
+
+from ...utils import check_schema
+
+
+name = "Analyse_GitLab"
+
+
+class AnalyseGitLab(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 GitLabAnalyseWrapper.model_construct().get_available_tools()
+        }
+        AnalyseGitLab.toolkit_max_length = get_max_toolkit_length(selected_tools)
+
+        return create_model(
+            "analyse_gitlab",
+            url=(
+                str,
+                Field(
+                    description="GitLab URL (e.g., git.epam.com)",
+                    json_schema_extra={"toolkit_name": True, "max_toolkit_length": AnalyseGitLab.toolkit_max_length}
+                )
+            ),
+            project_ids=(Optional[str], Field(description="GitLab project ids separated by comma", default=None)),
+            jira_project_keys=(Optional[str],
+                               Field(description="GitLab project Jira keys separated by comma", default=None)),
+            token=(SecretStr, Field(description="GitLab Personal Access Token", json_schema_extra={"secret": True})),
+            default_branch_name=(Optional[str], Field(description="Default branch name", default="master")),
+            artifact_bucket_path=(Optional[str], Field(description="Artifact Bucket Path", default="analyse-gitlab")),
+            selected_tools=(
+                List[Literal[tuple(selected_tools)]],
+                Field(default=[], json_schema_extra={"args_schemas": selected_tools})
+            ),
+            __config__=ConfigDict(json_schema_extra={"metadata": {
+                "label": "Analyse_GitLab",
+                "icon_url": "gitlab-icon.svg", # if 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-gitlab"
+        artifact_wrapper = ArtifactWrapper(client=client, bucket=bucket_path)
+        check_schema(artifact_wrapper)
+
+        jira_project_keys = kwargs.get("jira_project_keys") or ""
+        project_ids = kwargs.get("project_ids")  or ""
+        url = kwargs.get("url")
+        token = kwargs.get("token")
+
+        if not url or not token:
+            raise ValueError("GitLab URL and token are required.")
+
+        gitlab_search = GitLabV4Search(
+            url=url,
+            default_branch_name=kwargs.get("default_branch_name", "master"),
+            token=token.get_secret_value(),
+        )
+
+        gitlab_analyse_wrapper = GitLabAnalyseWrapper(
+            artifacts_wrapper=artifact_wrapper,
+            project_ids=project_ids,
+            jira_project_keys=jira_project_keys,
+            gitlab_search=gitlab_search,
+        )
+
+        selected_tools = selected_tools or []
+        available_tools = gitlab_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=gitlab_analyse_wrapper,
+                    name=tool["name"],
+                    description=tool["description"],
+                    args_schema=tool["args_schema"],
+                )
+            )
+
+        return cls(tools=tools)

alita_sdk/community/analysis/gitlab_analyse/api_wrapper.py

@@ -0,0 +1,173 @@
+import logging
+from typing import Any
+from pydantic import BaseModel, Field
+from typing import Optional
+
+from elitea_analyse.git.main import (
+    get_git_projects_list,
+    get_git_projects_that_in_jira,
+    get_git_commits,
+    get_git_merge_requests,
+)
+from elitea_analyse.git.git_search import GitLabV4Search
+
+
+from alita_tools.elitea_base import BaseToolApiWrapper
+from src.alita_sdk.utils.save_dataframe import save_dataframe_to_artifact
+from ....tools.artifact import ArtifactWrapper
+
+
+logger = logging.getLogger(__name__)
+
+
+class GitLabProjectsListArgs(BaseModel):
+    date: str = Field(
+        description="Filter projects by last activity date in 'YYYY-MM-DD' format."
+    )
+
+class GitLabProjectsListInJiraArgs(BaseModel):
+    jira_project_keys: Optional[str] = Field(description="Comma-separated Jira project keys.", default=None)
+
+class GitLabCommitsArgs(BaseModel):
+    project_ids: Optional[str] = Field(description="GitLab project ID.", default=None)
+    since_date:str = Field(description="Date filter in 'YYYY-MM-DD' format.")
+
+
+class GitLabAnalyseWrapper(BaseToolApiWrapper):
+    artifacts_wrapper: ArtifactWrapper
+    project_ids: str  # Comma-separated list of GitLab project IDs
+    jira_project_keys: str  # Comma-separated list of Jira projects' keys
+    gitlab_search: GitLabV4Search  # GitLab search client
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def get_gitlab_projects_list(self, date: str) -> str:
+        """
+        Get projects list that user has access to in GitLab.
+
+        date: str
+            Filter projects by last activity date.
+            Date in 'YYYY-MM-DD' format.
+        """
+
+        df_project_list = get_git_projects_list(date, git=self.gitlab_search)
+
+        save_dataframe_to_artifact(
+            self.artifacts_wrapper, df_project_list, "gitlab_projects_info.csv", csv_options={"index": False}
+        )
+
+        return (
+            f"You have access to {len(df_project_list)}. "
+            f"Data has been downloaded to the bucket as 'gitlab_projects_info.csv'"
+        )
+
+    def get_gitlab_projects_that_in_jira(self, jira_project_keys: Optional[str] = None) -> str:
+        """
+        Find GitLab projects that correspond to Jira projects by matching names.
+
+        jira_project_keys: str
+            Comma-separated Jira project keys.
+        """
+        jira_project_keys = jira_project_keys or self.jira_project_keys
+        df_projects = get_git_projects_that_in_jira(
+            jira_project_keys, git=self.gitlab_search)
+
+        if df_projects is None or df_projects.empty:
+            return "No GitLab projects found that match the provided Jira project keys."
+
+        save_dataframe_to_artifact(
+            self.artifacts_wrapper, df_projects, "gitlab_projects_that_in_Jira.csv", csv_options={"index": False},
+        )
+
+        return (
+            f"Found {len(df_projects)} GitLab projects that match Jira project names. "
+            f"Data has been downloaded to the bucket as 'gitlab_projects_that_in_Jira.csv'."
+        )
+
+    def get_gitlab_commits(self, project_ids: Optional[str], since_date: str,
+    ) -> str:
+        """
+        Get commit data for specified GitLab project.
+
+        project_id: str
+            GitLab project ID.
+        since_date: str
+            Date filter in 'YYYY-MM-DD' format.
+        """
+        project_ids = project_ids or self.project_ids
+        df_commits = get_git_commits(
+            project_ids, since_date, git_search=self.gitlab_search
+        )
+
+        if df_commits is None or df_commits.empty:
+            return f'There are no commits in the project {project_ids} created after {since_date}'
+
+        save_dataframe_to_artifact(
+            self.artifacts_wrapper, df_commits, f"commits_details_{project_ids}.csv", csv_options={"index": False},
+        )
+
+        return (
+            f"Commits data for project {project_ids} has been saved. "
+            f"Data has been downloaded to the bucket as 'commits_details_{project_ids}.csv'."
+        )
+
+    def get_gitlab_merge_requests(self, project_ids: Optional[str], since_date: str) -> str:
+        """
+        Get merge requests for specified GitLab project.
+
+        project_ids: str
+            GitLab project ID.
+        since_date: str
+            Date filter in 'YYYY-MM-DD' format.
+        """
+        project_ids = project_ids or self.project_ids
+        df_mrs = get_git_merge_requests(
+            project_ids, since_date, git_search=self.gitlab_search)
+
+        if df_mrs is None or df_mrs.empty:
+            return f'There are no merge requests in the project {project_ids} created after {since_date}'
+
+        save_dataframe_to_artifact(
+            self.artifacts_wrapper, df_mrs, f"merge_requests_details_{project_ids}.csv", csv_options={"index": False},
+        )
+
+        return (
+            f"Merge requests data for project {project_ids} has been saved. "
+            f"Data has been downloaded to the bucket as 'merge_requests_details_{project_ids}.csv'."
+        )
+
+
+    def get_available_tools(self):
+        return [
+            {
+                "name": "get_gitlab_projects_list",
+                "description": self.get_gitlab_projects_list.__doc__,
+                "args_schema": GitLabProjectsListArgs ,
+                "ref": self.get_gitlab_projects_list
+            },
+            {
+                "name": "get_gitlab_projects_that_in_jira",
+                "description": self.get_gitlab_projects_that_in_jira.__doc__,
+                "args_schema": GitLabProjectsListInJiraArgs,
+                "ref": self.get_gitlab_projects_that_in_jira
+            },
+            {
+                "name": "get_gitlab_commits",
+                "description": self.get_gitlab_commits.__doc__,
+                "args_schema": GitLabCommitsArgs,
+                "ref": self.get_gitlab_commits
+            },
+            {
+                "name": "get_gitlab_merge_requests",
+                "description": self.get_gitlab_merge_requests.__doc__,
+                "args_schema": GitLabCommitsArgs,
+                "ref": self.get_gitlab_merge_requests
+            }
+        ]
+
+    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/jira_analyse/api_wrapper.py

@@ -33,13 +33,15 @@ class GetJiraIssuesArgs(BaseModel):
         description="One or more projects keys separated with comma.", default=''
     )
     closed_issues_based_on: int = Field(
-        description="Define whether issues can be thought as closed based on their status (1) or not empty resolved date (2)."
+        description=("Define whether issues can be thought as closed based on their status (1) "
+                     "or not empty resolved date (2).")
     )
     resolved_after: str = Field(description="Resolved 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).")
     add_filter: Optional[str] = Field(
-        description="Additional filter for Jira issues in JQL format like 'customfield_10000 = 'value' AND customfield_10001 = 'value'"
+        description=("Additional filter for Jira issues in JQL format like "
+                     "'customfield_10000 = 'value' AND customfield_10001 = 'value'")
     )
 
 
@@ -111,7 +113,8 @@ class JiraAnalyseWrapper(BaseToolApiWrapper):
         created_after: str
             created after date (i.e. 2023-01-01)
         add_filter: str
-            additional filter for Jira issues in JQL format like "customfield_10000 = 'value' AND customfield_10001 = 'value'"
+            additional filter for Jira issues in JQL format 
+            like "customfield_10000 = 'value' AND customfield_10001 = 'value'"
         project_keys: str
             one or more projects keys separated with comma
         """
@@ -124,7 +127,8 @@ class JiraAnalyseWrapper(BaseToolApiWrapper):
             or closed_issues_based_on == 2
         ):
             return (
-                "ERROR: Check input parameters closed_issues_based_on and closed_status"
+                f"ERROR: Check input parameters closed_issues_based_on ({closed_issues_based_on}) "
+                f"and closed_status ({self.closed_status}) not in Jira statuses list."
             )
 
         project_keys = project_keys or self.project_keys
@@ -244,5 +248,5 @@ class JiraAnalyseWrapper(BaseToolApiWrapper):
         for tool in self.get_available_tools():
             if tool["name"] == mode:
                 return tool["ref"](*args, **kwargs)
-        else:
-            raise ValueError(f"Unknown mode: {mode}")
+
+        raise ValueError(f"Unknown mode: {mode}")

alita_sdk/langchain/langraph_agent.py

@@ -676,7 +676,7 @@ def merge_subgraphs(parent_yaml: str, registry: Dict[str, Dict[str, Any]]) -> Di
     regular_nodes = []
 
     for node in parent_def.get('nodes', []):
-        if node.get('type') == 'subgraph':
+        if node.get('type') == 'subgraph' or node.get('type') == 'pipeline':
             subgraph_nodes.append(node)
         else:
             regular_nodes.append(node)
@@ -846,7 +846,7 @@ def detect_and_flatten_subgraphs(yaml_schema: str) -> tuple[str, list]:
     schema_dict = yaml.safe_load(yaml_schema)
     subgraph_nodes = [
         node for node in schema_dict.get('nodes', [])
-        if node.get('type') == 'subgraph'
+        if node.get('type') == 'subgraph' or node.get('type') == 'pipeline'
     ]
 
     if not subgraph_nodes:

alita_sdk/toolkits/tools.py

@@ -11,6 +11,10 @@ from .subgraph import SubgraphToolkit
 from .vectorstore import VectorStoreToolkit
 ## Community tools and toolkits
 from ..community.analysis.jira_analyse import AnalyseJira
+from ..community.analysis.ado_analyse import AnalyseAdo
+from ..community.analysis.gitlab_analyse import AnalyseGitLab
+from ..community.analysis.github_analyse import AnalyseGithub
+
 from ..community.browseruse import BrowserUseToolkit
 
 from ..tools.mcp_server_tool import McpServerTool
@@ -26,12 +30,15 @@ def get_toolkits():
         ArtifactToolkit.toolkit_config_schema(),
         VectorStoreToolkit.toolkit_config_schema()
     ]
-    
-    community_toolkits = [ 
+
+    community_toolkits = [
         AnalyseJira.toolkit_config_schema(),
-        BrowserUseToolkit.toolkit_config_schema()
+        AnalyseAdo.toolkit_config_schema(),
+        AnalyseGitLab.toolkit_config_schema(),
+        AnalyseGithub.toolkit_config_schema(),
+        BrowserUseToolkit.toolkit_config_schema(),
     ]
-    
+
     return  core_toolkits + community_toolkits + alita_toolkits()
 
 
@@ -81,6 +88,18 @@ def get_tools(tools_list: list, alita_client, llm) -> list:
             tools.extend(AnalyseJira.get_toolkit(
                 client=alita_client,
                 **tool['settings']).get_tools())
+        if tool['type'] == 'analyse_ado':
+            tools.extend(AnalyseAdo.get_toolkit(
+                client=alita_client,
+                **tool['settings']).get_tools())
+        if tool['type'] == 'analyse_gitlab':
+            tools.extend(AnalyseGitLab.get_toolkit(
+                client=alita_client,
+                **tool['settings']).get_tools())
+        if tool['type'] == 'analyse_github':
+            tools.extend(AnalyseGithub.get_toolkit(
+                client=alita_client,
+                **tool['settings']).get_tools())
         if tool['type'] == 'browser_use':
             tools.extend(BrowserUseToolkit.get_toolkit(
                 client=alita_client,
@@ -137,7 +156,7 @@ def _init_single_mcp_tool(toolkit_name, available_tool, alita, toolkit_settings)
             ),
             client=alita,
             server=toolkit_name,
-            tool_timeout_sec=toolkit_settings["timeout"]
+            tool_timeout_sec=toolkit_settings.get("timeout", 90)
         )
     except Exception as e:
         logger.error(f"Failed to create McpServerTool for '{toolkit_name}.{tool_name}': {e}")

alita_sdk/utils/save_dataframe.py

@@ -0,0 +1,47 @@
+import logging
+
+from io import StringIO
+from typing import Any, Dict, Optional
+
+from langchain_core.tools import ToolException
+import pandas as pd
+
+from src.alita_sdk.tools.artifact import ArtifactWrapper
+
+logger = logging.getLogger(__name__)
+
+
+def save_dataframe_to_artifact(
+    artifacts_wrapper: ArtifactWrapper,
+    df: pd.DataFrame,
+    target_file: str,
+    csv_options: Optional[Dict[str, Any]] = None,
+):
+    """
+    Save a pandas DataFrame as a CSV file in the artifact repository using the ArtifactWrapper.
+
+    Args:
+        df (pd.DataFrame): The DataFrame to save.
+        target_file (str): The target file name in the storage (e.g., "file.csv").
+        csv_options: Dictionary of options to pass to Dataframe.to_csv()
+
+    Raises:
+        ValueError: If the DataFrame is empty or the file name is invalid.
+        Exception: If saving to the artifact repository fails.
+    """
+
+    csv_options = csv_options or {}
+
+    # Use StringIO to save the DataFrame as a string
+    try:
+        buffer = StringIO()
+        df.to_csv(buffer, **csv_options)
+        artifacts_wrapper.create_file(target_file, buffer.getvalue())
+        logger.info(
+            f"Successfully saved dataframe to {target_file} in bucket{artifacts_wrapper.bucket}"
+        )
+    except Exception as e:
+        logger.exception("Failed to save DataFrame to artifact repository")
+        return ToolException(
+            f"Failed to save DataFrame to artifact repository: {str(e)}"
+        )

{alita_sdk-0.3.129.dist-info → alita_sdk-0.3.131.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.129
+Version: 0.3.131
 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>
 Project-URL: Homepage, https://projectalita.ai

{alita_sdk-0.3.129.dist-info → alita_sdk-0.3.131.dist-info}/RECORD

@@ -10,8 +10,14 @@ alita_sdk/clients/prompt.py,sha256=li1RG9eBwgNK_Qf0qUaZ8QNTmsncFrAL2pv3kbxZRZg,1
 alita_sdk/community/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/community/utils.py,sha256=lvuCJaNqVPHOORJV6kIPcXJcdprVW_TJvERtYAEgpjM,249
 alita_sdk/community/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+alita_sdk/community/analysis/ado_analyse/__init__.py,sha256=JU-WsNdLp6GyhgftwW0COE37bAH3mciOFYYw58FawwQ,4056
+alita_sdk/community/analysis/ado_analyse/api_wrapper.py,sha256=qLkpm4XPmhuDC0nJwXAaDOcuI3XURVjYLufpKZ9NJnY,8649
+alita_sdk/community/analysis/github_analyse/__init__.py,sha256=QHVuYoTw6r89smShN3Iurhz_XLicPk1G8s2HeOMEk1s,3550
+alita_sdk/community/analysis/github_analyse/api_wrapper.py,sha256=pDZlpufTWSCtD0m-TI9aIgctFe62uJ7diX3LTsPdWjY,6836
+alita_sdk/community/analysis/gitlab_analyse/__init__.py,sha256=J_HwgZGfiQPxEqFD0IOulgettTI_fvpuqYdR_ciKRFw,4131
+alita_sdk/community/analysis/gitlab_analyse/api_wrapper.py,sha256=GDP_cW8Faa695357M9YXPsQ12WBP33JZQy5CGcCAS1A,6343
 alita_sdk/community/analysis/jira_analyse/__init__.py,sha256=Rm-HKEi_HIxrgHdq9mZ-XzxMKLXm8-81eJwJT2lar-c,5945
-alita_sdk/community/analysis/jira_analyse/api_wrapper.py,sha256=JqGSxg_3x0ErzII31UZkY3V7jo9i8Gb5d_pW7lPIOSA,9522
+alita_sdk/community/analysis/jira_analyse/api_wrapper.py,sha256=naEgBSdwNonNleUtHCb1UOkWiYdM64ZJ9dfsyszmeX8,9668
 alita_sdk/community/browseruse/__init__.py,sha256=uAxPZEX7ihpt8HtcGDFrzTNv9WcklT1wG1ItTwUO8y4,3601
 alita_sdk/community/browseruse/api_wrapper.py,sha256=Y05NKWfTROPmBxe8ZFIELSGBX5v3RTNP30OTO2Tj8uI,10838
 alita_sdk/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,7 +25,7 @@ alita_sdk/langchain/assistant.py,sha256=J_xhwbNl934BgDKSpAMC9a1u6v03DZQcTYaamCzt
 alita_sdk/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
 alita_sdk/langchain/constants.py,sha256=eHVJ_beJNTf1WJo4yq7KMK64fxsRvs3lKc34QCXSbpk,3319
 alita_sdk/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
-alita_sdk/langchain/langraph_agent.py,sha256=mPoyC2fJWf8F29lEZfhjh6_Cx_TQNXqmikBy6zQxqVI,39849
+alita_sdk/langchain/langraph_agent.py,sha256=BkrbYMy4BPAvy9uANH3s9ffBzaGewKFK97evN90L5kY,39917
 alita_sdk/langchain/mixedAgentParser.py,sha256=M256lvtsL3YtYflBCEp-rWKrKtcY1dJIyRGVv7KW9ME,2611
 alita_sdk/langchain/mixedAgentRenderes.py,sha256=asBtKqm88QhZRILditjYICwFVKF5KfO38hu2O-WrSWE,5964
 alita_sdk/langchain/utils.py,sha256=Npferkn10dvdksnKzLJLBI5bNGQyVWTBwqp3vQtUqmY,6631
@@ -69,7 +75,7 @@ alita_sdk/toolkits/artifact.py,sha256=7zb17vhJ3CigeTqvzQ4VNBsU5UOCJqAwz7fOJGMYqX
 alita_sdk/toolkits/datasource.py,sha256=v3FQu8Gmvq7gAGAnFEbA8qofyUhh98rxgIjY6GHBfyI,2494
 alita_sdk/toolkits/prompt.py,sha256=WIpTkkVYWqIqOWR_LlSWz3ug8uO9tm5jJ7aZYdiGRn0,1192
 alita_sdk/toolkits/subgraph.py,sha256=ZYqI4yVLbEPAjCR8dpXbjbL2ipX598Hk3fL6AgaqFD4,1758
-alita_sdk/toolkits/tools.py,sha256=eb4UFaSky0N42cTXHiJ9KojaReivcRNr2RM4UABQf8o,5928
+alita_sdk/toolkits/tools.py,sha256=WYR__mieQ-9ouL7ofI8IyRLllnyYbh0N1S6YX9IZNlU,6790
 alita_sdk/toolkits/vectorstore.py,sha256=di08-CRl0KJ9xSZ8_24VVnPZy58iLqHtXW8vuF29P64,2893
 alita_sdk/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/tools/agent.py,sha256=m98QxOHwnCRTT9j18Olbb5UPS8-ZGeQaGiUyZJSyFck,3162
@@ -92,12 +98,16 @@ alita_sdk/utils/AlitaCallback.py,sha256=cvpDhR4QLVCNQci6CO6TEUrUVDZU9_CRSwzcHGm3
 alita_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/utils/evaluate.py,sha256=iM1P8gzBLHTuSCe85_Ng_h30m52hFuGuhNXJ7kB1tgI,1872
 alita_sdk/utils/logging.py,sha256=hBE3qAzmcLMdamMp2YRXwOOK9P4lmNaNhM76kntVljs,3124
+alita_sdk/utils/save_dataframe.py,sha256=6aHFr28Ssw2jmsnrCTVfZIE2MCpVkG6GV58gzMN-Eao,1477
 alita_sdk/utils/streamlit.py,sha256=zp8owZwHI3HZplhcExJf6R3-APtWx-z6s5jznT2hY_k,29124
 alita_sdk/utils/utils.py,sha256=dM8whOJAuFJFe19qJ69-FLzrUp6d2G-G6L7d4ss2XqM,346
-alita_sdk-0.3.129.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.131.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_jira_analysis.py,sha256=I0cErH5R_dHVyutpXrM1QEo7jfBuKWTmDQvJBPjx18I,3281
-alita_sdk-0.3.129.dist-info/METADATA,sha256=HRyKs3QA8Q-vF56MHtzey9Jq7veAPj5a5j93s1Jv5AQ,7076
-alita_sdk-0.3.129.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.129.dist-info/top_level.txt,sha256=SWRhxB7Et3cOy3RkE5hR7OIRnHoo3K8EXzoiNlkfOmc,25
-alita_sdk-0.3.129.dist-info/RECORD,,
+tests/test_ado_analysis.py,sha256=wsxB4B2Ycxoiykthh6YbPQ9hqsDbPFie8D9ZK1i_6kg,3311
+tests/test_github_analysis.py,sha256=ulR4CEGmiMRPydJuX7aQcglzvhC7kFOAtZRLLBB9F_M,3148
+tests/test_gitlab_analysis.py,sha256=J7Y2mNi5Sj8-rH2PMRmVbT3uwZ17YeR9pcs0MDIyNW4,3352
+tests/test_jira_analysis.py,sha256=6F3Elikt02L28N6sS_AKDy9lgqgD81_hr979NcdZeg4,3359
+alita_sdk-0.3.131.dist-info/METADATA,sha256=u6rbcQEd9_oXtzErr6KKmk6ZUxEq9XoUmH6Y5Utfjzk,7076
+alita_sdk-0.3.131.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.131.dist-info/top_level.txt,sha256=SWRhxB7Et3cOy3RkE5hR7OIRnHoo3K8EXzoiNlkfOmc,25
+alita_sdk-0.3.131.dist-info/RECORD,,

tests/test_ado_analysis.py

@@ -0,0 +1,99 @@
+import os
+import pytest
+from dotenv import load_dotenv
+
+from elitea_analyse.ado.azure_search import AzureSearch
+
+from ..alita_sdk.community.analysis.ado_analyse.api_wrapper import (
+    GetAdoWorkItemsArgs, AdoCommitsArgs, AdoAnalyseWrapper)
+
+from ..alita_sdk.clients.client import AlitaClient
+from ..alita_sdk.tools.artifact import ArtifactWrapper
+from ..alita_sdk.community.utils import check_schema
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+@pytest.fixture
+def ado_api_wrapper():
+    base_url = os.getenv("DEPLOYMENT_URL")
+    project_id = os.getenv("PROJECT_ID")
+    api_key = os.getenv("API_KEY")
+
+    if not base_url or not project_id or not api_key:
+        raise ValueError("Environment variables DEPLOYMENT_URL, PROJECT_ID, and API_KEY must be set.")
+
+    client = AlitaClient(
+        base_url=base_url,
+        project_id=int(project_id),
+        auth_token=api_key,
+    )
+
+    artifacts_wrapper = ArtifactWrapper(
+        client=client, bucket=os.getenv("ARTIFACT_BUCKET_PATH", "analyse-ado")
+    )
+    check_schema(artifacts_wrapper)
+    ado_search = AzureSearch(
+        organization=os.getenv("ADO_ORGANIZATION", "john.doe@epam.com"),
+        user=os.getenv("ADO_USER", "ado_user"),
+        token=os.getenv("ADO_TOKEN", "1111"),
+    )
+
+    ado_wrapper = AdoAnalyseWrapper(
+        artifacts_wrapper=artifacts_wrapper,
+        project_keys=os.getenv("ADO_PROJECTS", "project1,project2"),
+        default_branch_name=os.getenv("ADO_DEFAULT_BRANCH", "main"),
+        area=os.getenv("ADO_AREA", ""),
+        ado_search=ado_search,
+    )
+    check_schema(ado_wrapper)
+
+    return ado_wrapper
+
+def test_get_projects_list(ado_api_wrapper):
+    result = ado_api_wrapper.get_projects_list()
+    assert isinstance(result, str)
+    assert "You have access to" in result
+
+def test_get_work_items(ado_api_wrapper):
+    args = GetAdoWorkItemsArgs(
+        resolved_after="2023-01-01",
+        updated_after="2023-01-01",
+        created_after="2023-01-01",
+    )
+    result = ado_api_wrapper.get_work_items(
+        resolved_after=args.resolved_after,
+        updated_after=args.updated_after,
+        created_after=args.created_after,
+        area=args.area,
+        project_keys=args.project_keys
+    )
+    assert isinstance(result, str)
+    assert f"Work items for {ado_api_wrapper.project_keys} have been successfully retrieved and saved to the bucket" in result
+
+@pytest.mark.asyncio
+async def test_get_commits(ado_api_wrapper):
+    args = AdoCommitsArgs(
+        since_date="2023-01-01",
+    )
+
+    result = await ado_api_wrapper.get_commits(since_date=args.since_date)
+    # breakpoint()
+    assert isinstance(result, str)
+    assert f"Commits for {ado_api_wrapper.project_keys} have been successfully" in result
+
+
+def test_get_merge_requests(ado_api_wrapper):
+    args = AdoCommitsArgs(
+        since_date="2023-01-01",
+    )
+
+    result = ado_api_wrapper.get_merge_requests(since_date=args.since_date)
+    assert isinstance(result, str)
+    assert f"Pull requests for {ado_api_wrapper.project_keys} have been successfully retrieved" in result
+
+def test_get_pipelines_runs(ado_api_wrapper):
+    result = ado_api_wrapper.get_pipelines_runs()
+    assert isinstance(result, str)
+    assert f"Pipeline runs for {ado_api_wrapper.project_keys} have been successfully retrieved " in result