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

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}")

alita_sdk/runtime/llms/alita.py

@@ -1,259 +0,0 @@
-# Copyright (c) 2023 Artem Rozumenko
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-#
-#  This is adoption of https://github.com/langchain-ai/langchain/blob/master/libs/community/langchain_community/chat_models/openai.py
-#
-
-import logging
-import requests
-from time import sleep
-from traceback import format_exc
-
-from typing import Any, List, Optional, AsyncIterator, Dict, Iterator, Mapping, Type
-from tiktoken import get_encoding, encoding_for_model
-from langchain_core.callbacks import (
-    AsyncCallbackManagerForLLMRun,
-    CallbackManagerForLLMRun,
-)
-from langchain_core.language_models import BaseChatModel, SimpleChatModel
-from langchain_core.messages import (AIMessageChunk, BaseMessage, HumanMessage, HumanMessageChunk, ChatMessageChunk, 
-                                     FunctionMessageChunk, SystemMessageChunk, ToolMessageChunk, BaseMessageChunk,
-                                     AIMessage)
-from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
-from langchain_core.runnables import run_in_executor
-from langchain_community.chat_models.openai import generate_from_stream, _convert_delta_to_message_chunk
-from ..clients.client import AlitaClient
-from pydantic import Field, model_validator, field_validator, ValidationInfo
-
-logger = logging.getLogger(__name__)
-
-
-class MaxRetriesExceededError(Exception):
-    """Raised when the maximum number of retries is exceeded"""
-    
-    def __init__(self, message="Maximum number of retries exceeded"):
-        self.message = message
-        super().__init__(self.message)
-
-
-class AlitaChatModel(BaseChatModel):
-    class Config:
-        populate_by_name = True
-
-    client: Any  #: :meta private:
-    encoding: Any  #: :meta private:
-    deployment: str = Field(default="https://eye.projectalita.ai", alias="base_url")
-    api_token: str = Field(default=None, alias="api_key")
-    project_id: int = None
-    model_name: Optional[str] = Field(default="gpt-35-turbo", alias="model")
-    integration_uid: Optional[str] = None
-    max_tokens: Optional[int] = 512
-    tiktoken_model_name: Optional[str] = None
-    tiktoken_encoding_name: Optional[str] = 'cl100k_base'
-    max_retries: Optional[int] = 2
-    temperature: Optional[float] = 0.7
-    top_p: Optional[float] = 0.9
-    top_k: Optional[int] = 20
-    stream_response: Optional[bool] = Field(default=False, alias="stream")
-    api_extra_headers: Optional[dict] = Field(default_factory=dict)
-    configurations: Optional[list] = Field(default_factory=list)
-    
-    @model_validator(mode="before")
-    @classmethod
-    def validate_env(cls, values: dict) -> Dict:
-        values['client'] = AlitaClient(
-            values.get('deployment', values.get('base_url', "https://eye.projectalita.ai")), 
-            values['project_id'], 
-            values.get('api_token', values.get('api_key')),
-            api_extra_headers=values.get('api_extra_headers', {}),
-            configurations=values.get('configurations', [])
-        )
-        if values.get("tiktoken_model_name"):
-            values["encoding"] = encoding_for_model(values["tiktoken_model_name"])
-        else:
-            values['encoding'] = get_encoding('cl100k_base')
-        return values
-    
-    def _generate(
-        self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
-        **kwargs: Any,
-    ) -> ChatResult:
-        
-        # TODO: Implement streaming
-        
-        if self.stream_response:
-            stream_iter = self._stream(
-                messages, stop=stop, run_manager=run_manager, **kwargs
-            )
-            return generate_from_stream(stream_iter)
-        self.stream_response = False
-        response = self.completion_with_retry(messages)
-        return self._create_chat_result(response)
-    
-    
-    def _stream(
-        self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
-        **kwargs: Any,
-    ) -> Iterator[ChatGenerationChunk]:
-        
-        self.stream_response = True
-        default_chunk_class = AIMessageChunk
-        for chunk in self.completion_with_retry(messages):
-            if not isinstance(chunk, dict):
-                chunk = chunk.dict()
-            logger.debug(f"Chunk: {chunk}")
-            if "delta" in chunk:
-                chunk = _convert_delta_to_message_chunk(
-                    chunk["delta"], default_chunk_class
-                )
-                finish_reason = chunk.get("z")
-                generation_info = (
-                    dict(finish_reason=finish_reason) if finish_reason is not None else None
-                )
-                default_chunk_class = chunk.__class__
-                cg_chunk = ChatGenerationChunk(
-                    message=chunk, generation_info=generation_info
-                )
-                if run_manager:
-                    run_manager.on_llm_new_token(cg_chunk.text, chunk=cg_chunk)
-                yield cg_chunk
-            else:
-                message = _convert_delta_to_message_chunk(chunk, default_chunk_class)
-                finish_reason = None
-                generation_info = dict()
-                if stop:
-                    for stop_word in stop:
-                        if stop_word in message.content:
-                            finish_reason = "stop"
-                            message.z = finish_reason
-                            break
-                    generation_info = (dict(finish_reason=finish_reason))
-                logger.debug(f"message before getting to ChatGenerationChunk: {message}")
-                yield ChatGenerationChunk(message=message, generation_info=generation_info)
-    
-    async def _astream(
-        self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
-        **kwargs: Any,
-    ) -> AsyncIterator[ChatGenerationChunk]:
-        iterator = await run_in_executor(
-            None,
-            self._stream,
-            messages,
-            stop,
-            run_manager.get_sync() if run_manager else None,
-            **kwargs,
-        )
-        done = object()
-        while True:
-            item: ChatGenerationChunk | object = await run_in_executor(
-                None,
-                next,
-                iterator,
-                done,
-            )
-            if item is done:
-                break
-            if isinstance(item, ChatGenerationChunk):
-                yield item
-    
-    def _create_chat_result(self, response: list[BaseMessage]) -> ChatResult:
-        token_usage = 0
-        generations = []
-        for message in response:
-            token_usage += len(self.encoding.encode(message.content))
-            generations.append(ChatGeneration(message=message))
-            
-        llm_output = {
-            "token_usage": token_usage,
-            "model_name": self.model_name,
-        }
-        
-        return ChatResult(
-            generations=generations,
-            llm_output=llm_output,
-        )
-            
-    def completion_with_retry(self, messages, retry_count=0):
-        try:
-            return self.client.predict(messages, self._get_model_default_parameters)
-        except requests.exceptions.HTTPError as e:
-            from json import loads
-            logger.error(f"ERROR: HTTPError in completion_with_retry: {e}, retry_count: {retry_count}")
-            sleep(60)
-            if retry_count >= self.max_retries:
-                logger.error(f"ERROR: Retry count exceeded: {format_exc()}")
-                raise MaxRetriesExceededError(format_exc())
-            return self.completion_with_retry(messages, retry_count+1)
-        except Exception as e:
-            logger.error(f"ERROR: Exception in completion_with_retry: {e}, retry_count: {retry_count}")
-            if retry_count >= self.max_retries:
-                logger.error(f"ERROR: Retry count exceeded: {format_exc()}")
-                raise MaxRetriesExceededError(format_exc())
-            return self.completion_with_retry(messages, retry_count+1)
-    
-    
-    # def _call(self, prompt:str, **kwargs: Any):
-    #     """
-    #     This is the main method that will be called when we run our LLM.
-    #     """
-    #     return self.client.predict([HumanMessage(content=prompt)], self._get_model_default_parameters)
-    
-    @property
-    def _llm_type(self) -> str:
-        """
-        This should return the type of the LLM.
-        """
-        return self.model_name
-    
-    @property
-    def _get_model_default_parameters(self):
-        return  {
-                "temperature": self.temperature,
-                "top_k": self.top_k,
-                "top_p": self.top_p,
-                "max_tokens": self.max_tokens,
-                "stream": self.stream_response,
-                "model": {
-                    "model_name": self.model_name,
-                    "integration_uid": self.integration_uid,
-                }
-            }
-    
-    @property
-    def _identifying_params(self) -> dict:
-        """
-        It should return a dict that provides the information of all the parameters 
-        that are used in the LLM. This is useful when we print our llm, it will give use the 
-        information of all the parameters.
-        """
-        return {
-            "deployment": self.deployment,
-            "api_token": self.api_token,
-            "project_id": self.project_id,
-            "integration_id": self.integration_uid,
-            "model_settings": self._get_model_default_parameters,
-        }
-
-