alita-sdk 0.3.206__py3-none-any.whl → 0.3.207__py3-none-any.whl

alita_sdk/community/analysis/gitlab_analyse/api_wrapper.py

@@ -1,172 +0,0 @@
-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_sdk.tools.elitea_base import BaseToolApiWrapper
-from alita_sdk.runtime.utils.save_dataframe import save_dataframe_to_artifact
-from alita_sdk.runtime.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, since_date: str, project_ids: Optional[str] = None) -> 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, since_date: str, project_ids: Optional[str] = None) -> 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/__init__.py

@@ -1,141 +0,0 @@
-import json
-from typing import List, Optional, Literal
-from pydantic import create_model, BaseModel, ConfigDict, Field
-
-from langchain_core.tools import BaseTool, BaseToolkit
-
-from elitea_analyse.jira.jira_connect import connect_to_jira
-from alita_sdk.tools.utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
-from alita_sdk.tools.base.tool import BaseAction
-from alita_sdk.runtime.clients.client import AlitaClient
-from alita_sdk.runtime.tools.artifact import ArtifactWrapper
-from .api_wrapper import JiraAnalyseWrapper
-
-from ...utils import check_schema
-
-name = "Analyse_Jira"
-
-class AnalyseJira(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
-                          JiraAnalyseWrapper.model_construct().get_available_tools()}
-        AnalyseJira.toolkit_max_length = get_max_toolkit_length(selected_tools)
-        return create_model(
-            "analyse_jira",
-            jira_base_url=(str, Field(
-                description="Jira URL",
-                json_schema_extra={
-                    'toolkit_name': True,
-                    'max_toolkit_length': AnalyseJira.toolkit_max_length                   
-                })
-            ),
-            jira_cloud=(bool, Field(description="Hosting Option")),
-            jira_username=(str, Field(description="Jira Username")),
-            jira_api_key=(Optional[str], Field(description="API key", json_schema_extra={'secret': True}, default="")),
-            jira_token=(Optional[str], Field(description="Jira token", json_schema_extra={'secret': True}, default="")),
-            # TODO: Add these fields to the schema as custom fields comma-separated if required
-            project_keys=(Optional[str], Field(description="Jira project keys separated by comma", default=None)),
-            team_field=(Optional[str], Field(description="Jira field used as identifier for team", default="")),
-            environment_field=(Optional[str], Field(description="Jira field used as identifier for environment", default="")),
-            defects_name=(Optional[str], Field(description="Jira defects type", default="")),
-            closed_status=(Optional[str], Field(description="Jira closed status", default="")),
-            jira_verify_ssl=(bool, Field(description="Verify SSL")),
-            jira_custom_fields=(Optional[dict], Field(description="Additional fields, split by comma", default={})),
-            artifact_bucket_path=(Optional[str], Field(description="Artifact Bucket Path", default="")),
-            selected_tools=(List[Literal[tuple(selected_tools)]],
-                           Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
-            __config__=ConfigDict(json_schema_extra={'metadata':
-                {
-                    "label": "Analyse_Jira",
-                    "icon_url": "jira-icon.svg",
-                    "hidden": False,
-                    "sections": {
-                        "auth": {
-                            "required": True,
-                            "subsections": [
-                                {
-                                    "name": "Api key",
-                                    "fields": ["jira_api_key"]
-                                },
-                                {
-                                    "name": "Token",
-                                    "fields": ["jira_token"]
-                                }
-                            ]
-                        }
-                    }
-                }
-            })
-        )
-
-    @classmethod
-    def get_toolkit(cls, client: "AlitaClient", selected_tools: list[str], **kwargs):
-        if selected_tools is None:
-            selected_tools = []
-
-        bucket_path = kwargs.get('artifact_bucket_path') or 'analyse-jira'
-        artifact_wrapper = ArtifactWrapper(
-            client=client, bucket=bucket_path
-        )
-        check_schema(artifact_wrapper)
-
-        project_keys = kwargs.get('project_keys') or ''
-
-        jira_base_url = kwargs.get('jira_base_url')
-        jira_verify_ssl = kwargs.get('jira_verify_ssl')
-        jira_username = kwargs.get('jira_username')
-        jira_token = kwargs.get('jira_token')
-        jira_api_key = kwargs.get('jira_api_key')
-       
-        jira_custom_fields = kwargs.get('jira_custom_fields', {})
-        jira_custom_fields['team'] = kwargs.get('team_field', '')
-        jira_custom_fields['environment'] = kwargs.get('environment_field', '')
-        closed_status = kwargs.get('closed_status', '')
-        defects_name = kwargs.get('defects_name', '')
-
-        jira_credentials = {
-            "username": jira_username,
-            "base_url": jira_base_url,
-            "token": jira_token,
-            "api_key": jira_api_key,
-            "verify_ssl": jira_verify_ssl
-        }
-
-        jira = connect_to_jira(credentials=jira_credentials)
-        if not jira:
-            raise ValueError(
-                "Failed to connect to Jira. Please check your credentials."
-            )
-
-        api_wrapper = JiraAnalyseWrapper(
-            artifacts_wrapper=artifact_wrapper,
-            jira=jira,
-            project_keys=project_keys,
-            closed_status=closed_status,
-            defects_name=defects_name,
-            custom_fields=jira_custom_fields,
-        )
-
-        tools = []
-        available_tools = api_wrapper.get_available_tools()
-        for tool in available_tools:
-            if selected_tools:
-                if tool["name"] not in selected_tools:
-                    continue
-            tools.append(
-                BaseAction(
-                    api_wrapper=api_wrapper,
-                    name=tool["name"],
-                    description=tool["description"],
-                    args_schema=tool["args_schema"],
-                )
-            )
-
-        return cls(tools=tools)
-
-    def get_tools(self):
-        return self.tools

alita_sdk/community/analysis/jira_analyse/api_wrapper.py

@@ -1,252 +0,0 @@
-import logging
-from io import StringIO
-from typing import Optional, List, Dict, Any
-from langchain_core.callbacks import dispatch_custom_event
-from langchain_core.tools import ToolException
-from pydantic import BaseModel, Field
-from jira import JIRA
-import pandas as pd
-
-
-from elitea_analyse.utils.constants import OUTPUT_MAPPING_FILE, OUTPUT_WORK_ITEMS_FILE
-from elitea_analyse.jira.jira_projects_overview import jira_projects_overview
-from elitea_analyse.jira.jira_statuses import get_all_statuses_list
-from elitea_analyse.jira.jira_issues import JiraIssues
- 
-from alita_sdk.tools.elitea_base import BaseToolApiWrapper
-from alita_sdk.runtime.tools.artifact import ArtifactWrapper
-from alita_sdk.runtime.utils.logging import with_streamlit_logs
-
-logger = logging.getLogger(__name__)
-
-
-class GetJiraFieldsArgs(BaseModel):
-    project_keys: Optional[str] = Field(
-        description="One or more projects keys separated with comma.",
-        default=''
-    )
-    after_date: str = Field(description="Date after which issues are considered.")
-
-
-class GetJiraIssuesArgs(BaseModel):
-    project_keys: Optional[str] = Field(
-        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).")
-    )
-    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'")
-    )
-
-
-class JiraAnalyseWrapper(BaseToolApiWrapper):
-    artifacts_wrapper: ArtifactWrapper
-    jira: JIRA
-    project_keys: str  # Jira project keys
-    closed_status: str  # Jira ticket closed statuses
-    defects_name: str  # Jira ticket defects name
-    custom_fields: dict  # Jira ticket custom fields
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    def get_number_off_all_issues(self, after_date: str, project_keys: Optional[str] = None):
-        """
-        Get projects a user has access to and merge them with issues count.
-        after_date: str
-            date after which issues are considered
-        project_keys: str
-            one or more projects keys separated with comma
-        """
-        project_keys = project_keys or self.project_keys
-
-        dispatch_custom_event(
-            name="thinking_step",
-            data={
-                "message": f"I am extracting number of all issues with initial parameters:\
-                    project keys: {project_keys},   after date: {after_date}",
-                "tool_name": "get_number_off_all_issues",
-                "toolkit": "analyse_jira",
-            },
-        )
-
-        project_df = jira_projects_overview(
-            after_date, project_keys=project_keys, jira=self.jira
-        )
-
-        # Save project_df DataFrame into the bucket
-        self.save_dataframe(
-            project_df,
-            f"projects_overview_{project_keys}.csv",
-            csv_options={"index": False},
-        )
-        return {
-            "projects": project_df["key"].tolist(),
-            "projects_summary": project_df.to_string(),
-        }
-
-    @with_streamlit_logs(tool_name="get_jira_issues")
-    def get_jira_issues(
-        self,
-        closed_issues_based_on: int,
-        resolved_after: str,
-        updated_after: str,
-        created_after: str,
-        add_filter: str = "",
-        project_keys: Optional[str] = None,
-    ):
-        """
-        Extract Jira issues for the specified projects.
-        closed_issues_based_on: int
-            define whether issues can be thought as 
-            closed based on their status (1) or not empty resolved date (2)
-        resolved_after: str
-            resolved after date (i.e. 2023-01-01)
-        updated_after: str
-            updated after date (i.e. 2023-01-01)
-        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'"
-        project_keys: str
-            one or more projects keys separated with comma
-        """
-
-        if not (
-            (
-                closed_issues_based_on == 1
-                and self.closed_status in get_all_statuses_list(jira=self.jira)
-            )
-            or closed_issues_based_on == 2
-        ):
-            return (
-                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
-
-        dispatch_custom_event(
-            name="thinking_step",
-            data={
-                "message": f"I am extracting Jira issues with initial parameters:\
-                    project keys: {project_keys}, closed status: {self.closed_status},\
-                    defects name: {self.defects_name}, custom fields: {self.custom_fields}, \
-                    closed status based on: {closed_issues_based_on}, resolved after: {resolved_after}, \
-                    updated after: {updated_after}, created after: {created_after}, additional filter:{add_filter}",
-                "tool_name": "jira_issues_extraction_start",
-                "toolkit": "analyse_jira",
-            },
-        )
-
-        jira_issues = JiraIssues(
-            self.jira,
-            project_keys,
-            (closed_issues_based_on, self.closed_status),
-            self.defects_name,
-            add_filter="",
-        )
-
-        df_issues, df_map = jira_issues.extract_issues_from_jira_and_transform(
-            self.custom_fields, (resolved_after, updated_after, created_after)
-        )
-
-        dispatch_custom_event(
-            name="thinking_step",
-            data={
-                "message": f"I am saving the extracted Jira issues to the artifact repository. \
-                            issues count: {len(df_issues)}, mapping rows: {len(df_map)}, \
-                            output file: {OUTPUT_MAPPING_FILE}{jira_issues.projects}.csv",
-                "tool_name": "get_jira_issues",
-                "toolkit": "analyse_jira",
-            },
-        )
-        self.save_dataframe(
-            df_map,
-            f"{OUTPUT_MAPPING_FILE}{jira_issues.projects}.csv",
-            csv_options={"index_label": "id"},
-        )
-
-        if not df_issues.empty:
-            self.save_dataframe(
-                df_issues,
-                f"{OUTPUT_WORK_ITEMS_FILE}{jira_issues.projects}.csv",
-                csv_options={"index_label": "id"},
-            )
-            dispatch_custom_event(
-                name="thinking_step",
-                data={
-                    "message": f"Saving Jira issues to the file . \
-                                 output file: {OUTPUT_WORK_ITEMS_FILE}{jira_issues.projects}.csv,\
-                                 row count: {len(df_issues)}",
-                    "tool_name": "get_jira_issues",
-                    "toolkit": "analyse_jira",
-                },
-            )
-
-        return f"{jira_issues.projects} Data has been extracted successfully."
-
-    def get_available_tools(self) -> List[Dict[str, Any]]:
-        """Get a list of available tools."""
-        return [
-            {
-                "name": "get_number_off_all_issues",
-                "description": self.get_number_off_all_issues.__doc__,
-                "args_schema": GetJiraFieldsArgs,
-                "ref": self.get_number_off_all_issues,
-            },
-            {
-                "name": "get_jira_issues",
-                "description": self.get_jira_issues.__doc__,
-                "args_schema": GetJiraIssuesArgs,
-                "ref": self.get_jira_issues,
-            },
-        ]
-
-    def save_dataframe(
-        self,
-        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)
-            self.artifacts_wrapper.create_file(target_file, buffer.getvalue())
-            logger.info(
-                f"Successfully saved dataframe to {target_file} in bucket {self.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)}"
-            )
-
-    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}")