alita-sdk 0.3.532__py3-none-any.whl → 0.3.602__py3-none-any.whl

alita_sdk/tools/openapi/tool.py

@@ -0,0 +1,20 @@
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field, field_validator
+
+from ..base.tool import BaseAction
+from .api_wrapper import OpenApiApiWrapper
+
+
+class OpenApiAction(BaseAction):
+    """Tool for executing a single OpenAPI operation."""
+
+    api_wrapper: OpenApiApiWrapper = Field(default_factory=OpenApiApiWrapper)
+    name: str
+    description: str = ""
+    args_schema: Optional[Type[BaseModel]] = None
+
+    @field_validator('name', mode='before')
+    @classmethod
+    def remove_spaces(cls, v: str) -> str:
+        return v.replace(' ', '')

alita_sdk/tools/pandas/__init__.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, ConfigDict, create_model, Field
 from .api_wrapper import PandasWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, get_max_toolkit_length
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "pandas"
 
@@ -29,9 +30,14 @@ class PandasToolkit(BaseToolkit):
             name,
             bucket_name=(str, Field(default=None, title="Bucket name", description="Bucket where the content file is stored")),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
-            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Pandas", "icon_url": "pandas-icon.svg",
-                                                                  "categories": ["analysis"],
-                                                                    "extra_categories": ["data science", "data manipulation", "dataframes"]}})
+            __config__=ConfigDict(json_schema_extra={'metadata': {
+                "label": "Pandas (Deprecated)",
+                "icon_url": "pandas-icon.svg",
+                "categories": ["analysis"],
+                "deprecated": True,
+                "deprecation_message": "This toolkit is deprecated. Use the 'Data Analysis' internal tool instead. Enable it via the 'Internal Tools' menu in chat.",
+                "extra_categories": ["data science", "data manipulation", "dataframes"]
+            }})
         )
 
     @classmethod
@@ -49,11 +55,11 @@ class PandasToolkit(BaseToolkit):
                 description = f"Toolkit: {toolkit_name}\n{description}"
             description = description[:1000]
             tools.append(BaseAction(
-                api_wrapper=csv_tool_api_wrapper,
+                api_wrapper=pandas_api_wrapper,
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/pandas/api_wrapper.py

@@ -158,39 +158,62 @@ class PandasWrapper(BaseToolApiWrapper):
                         f"Retrying Code Generation ({attempts}/{max_retries})..."
                     )
     
-    def process_query(self, query: str, filename: str) -> str:
-        """Analyze and process using query on dataset""" 
+    def pandas_analyze_data(self, query: str, filename: str) -> str:
+        """Analyze data from a file using natural language query.
+        
+        This tool allows you to perform data analysis operations on files using natural language.
+        It automatically generates and executes Python pandas code based on your query.
+        
+        Supported file formats: CSV, Excel (.xlsx, .xls), Parquet, JSON, XML, HDF5, Feather, Pickle
+        
+        Parameters:
+            query: Natural language description of the analysis to perform. Examples:
+                - "Calculate the average sales by region"
+                - "Show me a bar chart of products by revenue"
+                - "Filter rows where price > 100 and status is 'active'"
+                - "What is the correlation between age and income?"
+            filename: Name of the file in the artifact bucket (e.g., 'sales_data.csv', 'report.xlsx')
+        
+        Returns:
+            Analysis results as text, or confirmation message if a chart was generated and saved.
+            Charts are automatically saved to the artifact bucket as PNG files.
+        
+        Examples:
+            - pandas_analyze_data(query="Show summary statistics", filename="data.csv")
+            - pandas_analyze_data(query="Create a histogram of ages", filename="customers.xlsx")
+            - pandas_analyze_data(query="What's the total revenue by month?", filename="sales.parquet")
+        """
         df = self._get_dataframe(filename)
         code = self.generate_code_with_retries(df, query)
-        self._log_tool_event(tool_name="process_query",
+        self._log_tool_event(tool_name="pandas_analyze_data",
                              message=f"Executing generated code... \n\n```python\n{code}\n```")
         try:
             result = self.execute_code(df, code)
         except Exception as e:
             logger.error(f"Code execution failed: {format_exc()}")
-            self._log_tool_event(tool_name="process_query",
-                                 message=f"Executing generated code... \n\n```python\n{code}\n```")
             raise
-        self._log_tool_event(tool_name="process_query",
-                             message=f"Executing generated code... \n\n```python\n{code}\n```")
         if result.get("df") is not None:
             df = result.pop("df")
             # Not saving dataframe to artifact repo for now
             # self._save_dataframe(df, filename)
         if result.get('chart'):
+            chart_results = []
             if isinstance(result['chart'], list):
                 for ind, chart in enumerate(result['chart']):
                     chart_filename = f"chart_{uuid4()}.png"
                     chart_data = base64.b64decode(chart)
                     self.alita.create_artifact(self.bucket_name, chart_filename, chart_data)
-                    result['result'] = f"Chart #{ind} saved to {chart_filename}"
+                    chart_url = f"{self.alita.base_url}/api/v1/artifacts/artifact/default/{self.alita.project_id}/{self.bucket_name}/{chart_filename}"
+                    chart_results.append(f"Chart #{ind+1} saved and available at: {chart_url}")
+                result['result'] = "\n".join(chart_results)
             else:
                 # Handle single chart case (not in a list)
                 chart = result['chart']
                 chart_filename = f"chart_{uuid4()}.png"
                 chart_data = base64.b64decode(chart)
                 self.alita.create_artifact(self.bucket_name, chart_filename, chart_data)
-                result['result'] = f"Chart saved to {chart_filename}"
+                chart_url = f"{self.alita.base_url}/api/v1/artifacts/artifact/default/{self.alita.project_id}/{self.bucket_name}/{chart_filename}"
+                result['result'] = f"Chart saved and available at: {chart_url}\n\nYou can embed this image in your response using markdown: ![Chart]({chart_url})"
         return result.get("result", None)
 
     def save_dataframe(self, source_df: str, target_file: str) -> str:
@@ -253,23 +276,13 @@ class PandasWrapper(BaseToolApiWrapper):
     def get_available_tools(self):
         return [
             {
-                "name": "process_query",
-                "ref": self.process_query,
-                "description": self.process_query.__doc__,
-                "args_schema": create_model(
-                    "ProcessQueryModel",
-                    query=(str, Field(description="Task to solve")),
-                    filename=(str, Field(description="File to be processed"))
-                )
-            },
-            {
-                "name": "save_dataframe",
-                "ref": self.save_dataframe,
-                "description": self.save_dataframe.__doc__,
+                "name": "pandas_analyze_data",
+                "ref": self.pandas_analyze_data,
+                "description": self.pandas_analyze_data.__doc__,
                 "args_schema": create_model(
-                    "SaveDataFrameModel",
-                    source_df=(str, Field(description="Source dataframe file to be saved")),
-                    target_file=(str, Field(description="Target filename with extension for saving"))
+                    "AnalyseDataModel",
+                    query=(str, Field(description="Natural language query describing what analysis to perform on the data")),
+                    filename=(str, Field(description="Name of the file to analyze (e.g., 'data.csv', 'report.xlsx')"))
                 )
             }
         ]

alita_sdk/tools/pandas/dataframe/generator/base.py

@@ -39,7 +39,9 @@ class CodeGenerator:
                 {"role": "user",  "content": [{"type": "text", "text": prompt}]}
             ]
             # Generate the code
-            code = self.llm.invoke(messages).content
+            from alita_sdk.runtime.langchain.utils import extract_text_from_completion
+            completion = self.llm.invoke(messages)
+            code = extract_text_from_completion(completion)
             return self.validate_and_clean_code(code)
 
         except Exception as e:

alita_sdk/tools/postman/__init__.py

@@ -8,6 +8,7 @@ from ..base.tool import BaseAction
 from .api_wrapper import PostmanApiWrapper
 from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from ...configurations.postman import PostmanConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "postman"
 
@@ -102,7 +103,7 @@ class PostmanToolkit(BaseToolkit):
                 mode=tool["mode"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/pptx/__init__.py

@@ -8,6 +8,7 @@ from .pptx_wrapper import PPTXWrapper
 
 from ..base.tool import BaseAction
 from ..utils import clean_string, get_max_toolkit_length
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 logger = logging.getLogger(__name__)
 
@@ -87,7 +88,7 @@ class PPTXToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
             
         return cls(tools=tools)

alita_sdk/tools/qtest/__init__.py

@@ -9,6 +9,8 @@ from .tool import QtestAction
 from ..elitea_base import filter_missconfigured_index_tools
 from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from ...configurations.qtest import QtestConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
+from ...configurations.pgvector import PgVectorConfiguration
 
 name = "qtest"
 
@@ -20,7 +22,14 @@ def get_tools(tool):
         no_of_tests_shown_in_dql_search=tool['settings'].get('no_of_tests_shown_in_dql_search'),
         qtest_configuration=tool['settings']['qtest_configuration'],
         toolkit_name=tool.get('toolkit_name'),
-        llm=tool['settings'].get('llm', None)
+        llm=tool['settings'].get('llm', None),
+        alita=tool['settings'].get('alita', None),
+
+        # indexer settings
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
+        collection_name=str(tool.get('toolkit_name', '')),
+        embedding_model=tool['settings'].get('embedding_model', None),
+        vectorstore_type="PGVector"
     )
     return toolkit.tools
 
@@ -38,6 +47,15 @@ class QtestToolkit(BaseToolkit):
             qtest_project_id=(int, Field(description="QTest project id")),
             no_of_tests_shown_in_dql_search=(Optional[int], Field(description="Max number of items returned by dql search",
                                                                   default=10)),
+            # indexer configuration
+            pgvector_configuration=(Optional[PgVectorConfiguration], Field(
+                default=None,
+                description="PgVector Configuration for indexing",
+                json_schema_extra={'configuration_types': ['pgvector']})),
+            embedding_model=(Optional[str], Field(
+                default=None,
+                description="Embedding model configuration for indexing",
+                json_schema_extra={'configuration_model': 'embedding'})),
 
         selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
@@ -71,6 +89,7 @@ class QtestToolkit(BaseToolkit):
             **kwargs,
             # TODO use qtest_configuration fields
             **kwargs['qtest_configuration'],
+            **(kwargs.get('pgvector_configuration') or {}),
         }
         qtest_api_wrapper = QtestApiWrapper(**wrapper_payload)
         available_tools = qtest_api_wrapper.get_available_tools()
@@ -89,7 +108,7 @@ class QtestToolkit(BaseToolkit):
                 mode=tool["mode"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)