alita-sdk 0.3.228__py3-none-any.whl → 0.3.230__py3-none-any.whl

alita_sdk/configurations/__init__.py

@@ -0,0 +1,66 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+AVAILABLE_CONFIGURATIONS = {}
+AVAILABLE_CLASS_CONFIGURATIONS = {}
+FAILED_IMPORTS = {}
+
+
+def _safe_import_configuration(
+    configuration_name, module_path, configuration_class_name
+):
+    """Safely import a configuration module and register available functions/classes."""
+    try:
+        module = __import__(f'alita_sdk.configurations.{module_path}', fromlist=[''])
+        configuration_class = getattr(module, configuration_class_name)
+        AVAILABLE_CONFIGURATIONS[configuration_name] = configuration_class.model_json_schema()
+        AVAILABLE_CLASS_CONFIGURATIONS[configuration_name] = configuration_class
+        logger.debug(f"Successfully imported {configuration_name}")
+    except Exception as e:
+        FAILED_IMPORTS[configuration_name] = str(e)
+        logger.debug(f"Failed to import {configuration_name}: {e}")
+
+# Safe imports for all tools
+_safe_import_configuration('github', 'github', 'GithubConfiguration')
+_safe_import_configuration('pgvector', 'pgvector', 'PgVectorConfiguration')
+_safe_import_configuration('ado', 'ado', 'AdoConfiguration')
+_safe_import_configuration('ado_repos', 'ado', 'AdoReposConfiguration')
+_safe_import_configuration('gitlab', 'gitlab', 'GitlabConfiguration')
+_safe_import_configuration('qtest', 'qtest', 'QtestConfiguration')
+_safe_import_configuration('bitbucket', 'bitbucket', 'BitbucketConfiguration')
+_safe_import_configuration('confluence', 'confluence', 'ConfluenceConfiguration')
+_safe_import_configuration('jira', 'jira', 'JiraConfiguration')
+_safe_import_configuration('postman', 'postman', 'PostmanConfiguration')
+_safe_import_configuration('service_now', 'service_now', 'ServiceNowConfiguration')
+_safe_import_configuration('testrail', 'testrail', 'TestRailConfiguration')
+_safe_import_configuration('slack', 'slack', 'SlackConfiguration')
+_safe_import_configuration('azure_search', 'azure_search', 'AzureSearchConfiguration')
+_safe_import_configuration('delta_lake', 'delta_lake', 'DeltaLakeConfiguration')
+_safe_import_configuration('bigquery', 'bigquery', 'BigQueryConfiguration')
+
+# Log import summary
+available_count = len(AVAILABLE_CONFIGURATIONS)
+total_attempted = len(AVAILABLE_CONFIGURATIONS) + len(FAILED_IMPORTS)
+logger.info(f"Configuration imports completed: {available_count}/{total_attempted} successful")
+
+
+def get_configurations():
+    """Return all available configuration schemas."""
+    return AVAILABLE_CONFIGURATIONS.copy()
+
+
+def get_class_configurations():
+    """Return all available configuration classes."""
+    return AVAILABLE_CLASS_CONFIGURATIONS.copy()
+
+
+def get_available_configurations():
+    """Return list of available configuration class names."""
+    return list(AVAILABLE_CONFIGURATIONS.keys())
+
+
+__all__ = [
+    'get_configurations',
+    'get_available_configurations',
+]

alita_sdk/configurations/ado.py

@@ -0,0 +1,41 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class AdoConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Ado",
+                "icon_url": None,
+                "section": "credentials",
+                "type": "ado"
+            }
+        }
+    )
+    organization_url: Optional[str] = Field(description="Base API URL")
+    project: Optional[str] = Field(description="ADO project", default=None)
+    token: Optional[SecretStr] = Field(description="ADO Token")
+
+
+class AdoReposConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "ADO repos",
+                "icon_url": "ado-repos-icon.svg",
+                "section": "credentials",
+                "type": "ado_repos"
+            }
+        }
+    )
+    repository_id: Optional[str] = Field(description="ADO repository ID", default=None)
+
+    ado_configuration: AdoConfiguration = Field(
+        default_factory=AdoConfiguration,
+        description="ADO configuration",
+        json_schema_extra={
+            'configuration_types': ['ado']
+        }
+    )

alita_sdk/configurations/azure_search.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class AzureSearchConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Azure Search",
+                "icon_url": "azure-search.svg",
+                "section": "credentials",
+                "type": "azure_search",
+                "categories": ["search"],
+                "extra_categories": ["azure", "cognitive search", "vector database", "knowledge base"],
+            }
+        }
+    )
+    endpoint: Optional[str] = Field(description="Azure Search endpoint")
+    api_base: Optional[str] = Field(description="Azure Search API base")
+    api_key: Optional[SecretStr] = Field(description="API key")

alita_sdk/configurations/bigquery.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class BigQueryConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Google BigQuery",
+                "icon_url": "google.svg",
+                "section": "credentials",
+                "type": "bigquery",
+                "categories": ["database"],
+                "extra_categories": ["google", "gcp", "data warehouse", "analytics"],
+            }
+        }
+    )
+    api_key: Optional[SecretStr] = Field(description="GCP API key")
+    project: Optional[str] = Field(description="BigQuery project ID")
+    location: Optional[str] = Field(description="BigQuery location")
+    dataset: Optional[str] = Field(description="BigQuery dataset name")
+    table: Optional[str] = Field(description="BigQuery table name")

alita_sdk/configurations/bitbucket.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class BitbucketConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Bitbucket",
+                "icon_url": "bitbucket-icon.svg",
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "Username & Password",
+                                "fields": ["username", "password"]
+                            }
+                        ]
+                    },
+                },
+                "section": "credentials",
+                "type": "bitbucket",
+                "categories": ["code repositories"],
+                "extra_categories": ["bitbucket", "git", "repository", "code", "version control"],
+            }
+        }
+    )
+    username: Optional[str] = Field(description="Bitbucket Username", default=None)
+    password: Optional[SecretStr] = Field(description="Bitbucket Password/App Password", default=None)

alita_sdk/configurations/confluence.py

@@ -0,0 +1,36 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class ConfluenceConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Confluence",
+                "icon_url": "confluence.svg",
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "API Key",
+                                "fields": ["username", "api_key"]
+                            },
+                            {
+                                "name": "Token",
+                                "fields": ["token"]
+                            }
+                        ]
+                    },
+                },
+                "section": "credentials",
+                "type": "confluence",
+                "categories": ["documentation"],
+                "extra_categories": ["confluence", "wiki", "documentation", "knowledge base"],
+            }
+        }
+    )
+    username: Optional[str] = Field(description="Confluence Username", default=None)
+    api_key: Optional[SecretStr] = Field(description="Confluence API Key", default=None)
+    token: Optional[SecretStr] = Field(description="Confluence Token", default=None)

alita_sdk/configurations/delta_lake.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class DeltaLakeConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "AWS Delta Lake",
+                "icon_url": "delta-lake.svg",
+                "section": "credentials",
+                "type": "delta_lake",
+                "categories": ["database"],
+                "extra_categories": ["aws", "data lake", "analytics", "storage"],
+            }
+        }
+    )
+    aws_access_key_id: Optional[SecretStr] = Field(description="AWS access key ID")
+    aws_secret_access_key: Optional[SecretStr] = Field(description="AWS secret access key")
+    aws_session_token: Optional[SecretStr] = Field(description="AWS session token (optional)")
+    aws_region: Optional[str] = Field(description="AWS region for Delta Lake storage")
+    s3_path: Optional[str] = Field(description="S3 path to Delta Lake data (e.g., s3://bucket/path)")
+    table_path: Optional[str] = Field(description="Delta Lake table path (if not using s3_path)")

alita_sdk/configurations/github.py

@@ -0,0 +1,45 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class GithubConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "GitHub",
+                "icon_url": None,
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "Token",
+                                "fields": ["access_token"]
+                            },
+                            {
+                                "name": "Password",
+                                "fields": ["username", "password"]
+                            },
+                            {
+                                "name": "App private key",
+                                "fields": ["app_id", "app_private_key"]
+                            }
+                        ]
+                    },
+                },
+                "section": "credentials",
+                "type": "github",
+                "categories": ["code repositories"],
+                "extra_categories": ["github", "git", "repository", "code", "version control"],
+            }
+        }
+    )
+    base_url: Optional[str] = Field(description="Base API URL", default="https://api.github.com")
+    app_id: Optional[str] = Field(description="Github APP ID", default=None)
+    app_private_key: Optional[SecretStr] = Field(description="Github APP private key", default=None)
+
+    access_token: Optional[SecretStr] = Field(description="Github Access Token", default=None)
+
+    username: Optional[str] = Field(description="Github Username", default=None)
+    password: Optional[SecretStr] = Field(description="Github Password", default=None)

alita_sdk/configurations/gitlab.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class GitlabConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "GitLab",
+                "icon_url": None,
+                "sections": {
+                    "auth": {
+                        "required": True,
+                        "subsections": [
+                            {
+                                "name": "GitLab private token",
+                                "fields": ["private_token"]
+                            }
+                        ]
+                    }
+                },
+                "section": "credentials",
+                "type": "gitlab",
+                "categories": ["code repositories"],
+                "extra_categories": ["gitlab", "git", "repository", "code", "version control"],
+            }
+        }
+    )
+    private_token: Optional[SecretStr] = Field(description="GitLab private token", default=None)
+

alita_sdk/configurations/jira.py

@@ -0,0 +1,36 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class JiraConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Jira",
+                "icon_url": "jira.svg",
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "API Key",
+                                "fields": ["username", "api_key"]
+                            },
+                            {
+                                "name": "Token",
+                                "fields": ["token"]
+                            }
+                        ]
+                    },
+                },
+                "section": "credentials",
+                "type": "jira",
+                "categories": ["project management"],
+                "extra_categories": ["jira", "issue tracking", "project management", "agile"],
+            }
+        }
+    )
+    username: Optional[str] = Field(description="Jira Username", default=None)
+    api_key: Optional[SecretStr] = Field(description="Jira API Key", default=None)
+    token: Optional[SecretStr] = Field(description="Jira Token", default=None)

alita_sdk/configurations/pgvector.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class PgVectorConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "PgVector",
+                "icon_url": None,
+                "section": "vectorstorage",
+                "type": "pgvector"
+            }
+        }
+    )
+    connection_string: SecretStr = Field(
+        description="Connection string for PgVector database",
+        default=None
+    )

alita_sdk/configurations/postman.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class PostmanConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Postman",
+                "icon_url": "postman.svg",
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "API Key",
+                                "fields": ["api_key"]
+                            }
+                        ]
+                    },
+                },
+                "section": "credentials",
+                "type": "postman",
+                "categories": ["api testing"],
+                "extra_categories": ["postman", "api", "testing", "collection"],
+            }
+        }
+    )
+    api_key: Optional[SecretStr] = Field(description="Postman API Key", default=None)

alita_sdk/configurations/qtest.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class QtestConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "QTest",
+                "icon_url": "qtest.svg",
+                "categories": ["test management"],
+                "section": "credentials",
+                "type": "qtest",
+                "extra_categories": ["quality assurance", "test case management", "test planning"]
+            }
+        }
+    )
+    qtest_api_token: Optional[SecretStr] = Field(description="QTest API token", default=None)
+

alita_sdk/configurations/service_now.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class ServiceNowConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "ServiceNow",
+                "icon_url": "servicenow.svg",
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "Username & Password",
+                                "fields": ["username", "password"]
+                            }
+                        ]
+                    },
+                },
+                "section": "credentials",
+                "type": "service_now",
+                "categories": ["service management"],
+                "extra_categories": ["servicenow", "itsm", "service management", "incident"],
+            }
+        }
+    )
+    username: Optional[str] = Field(description="ServiceNow Username", default=None)
+    password: Optional[SecretStr] = Field(description="ServiceNow Password", default=None)

alita_sdk/configurations/slack.py

@@ -0,0 +1,35 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class SlackConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Slack",
+                "icon_url": "slack.svg",
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "Bot Token",
+                                "fields": ["bot_token"]
+                            },
+                            {
+                                "name": "User Token",
+                                "fields": ["user_token"]
+                            }
+                        ]
+                    },
+                },
+                "section": "credentials",
+                "type": "slack",
+                "categories": ["communication"],
+                "extra_categories": ["slack", "chat", "messaging", "collaboration"],
+            }
+        }
+    )
+    name: Optional[SecretStr] = Field(description="Slack Bot Token")
+    slack_token: Optional[SecretStr] = Field(description="Slack Token like XOXB-*****-*****-*****-*****")

alita_sdk/configurations/testrail.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class TestRailConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "TestRail",
+                "icon_url": "testrail.svg",
+                "section": "credentials",
+                "type": "testrail",
+                "categories": ["test management"],
+                "extra_categories": ["testrail", "test management", "quality assurance", "testing"],
+            }
+        }
+    )
+    email: Optional[str] = Field(description="TestRail Email", default=None)
+    password: Optional[SecretStr] = Field(description="TestRail Password", default=None)

alita_sdk/runtime/langchain/document_loaders/AlitaDocLoader.py

@@ -0,0 +1,29 @@
+from langchain_core.document_loaders import BaseLoader
+from langchain_core.documents import Document
+
+from .utils import file_to_bytes
+
+
+class AlitaDocLoader(BaseLoader):
+
+    def __init__(self, **kwargs):
+        if kwargs.get('file_path'):
+            self.file_path = kwargs['file_path']
+        elif kwargs.get('file_content'):
+            self.file_content = kwargs['file_content']
+            self.file_name = kwargs['file_name']
+        else:
+            raise ValueError(
+                "Path parameter is required (either as 'file_path' positional argument or 'path' keyword argument)")
+
+    def load(self):
+        result_content = self.get_content()
+        return [Document(page_content=result_content, metadata={'source': str(self.file_path if hasattr(self, 'file_path') else self.file_name)})]
+
+    def get_content(self):
+        try:
+            import textract
+            content = textract.process(None, extension='doc', input_data=self.file_content if hasattr(self, 'file_content') else file_to_bytes(self.file_path)).decode('utf-8')
+        except Exception as e:
+            content = f"[Error extracting doc: {str(e)}]"
+        return content

alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -18,6 +18,7 @@ from langchain_community.document_loaders import (
         UnstructuredPowerPointLoader, PythonLoader)
 
 from .AlitaCSVLoader import AlitaCSVLoader
+from .AlitaDocLoader import AlitaDocLoader
 from .AlitaDocxMammothLoader import AlitaDocxMammothLoader
 from .AlitaExcelLoader import AlitaExcelLoader
 from .AlitaImageLoader import AlitaImageLoader
@@ -124,6 +125,11 @@ loaders_map = {
         'is_multimodal_processing': True,
         'kwargs': {}
     },
+    '.doc': {
+        'class': AlitaDocLoader,
+        'is_multimodal_processing': True,
+        'kwargs': {}
+    },
     '.json': {
         'class': AlitaTextLoader,
         'is_multimodal_processing': False,

alita_sdk/runtime/langchain/document_loaders/utils.py

@@ -60,4 +60,25 @@ def create_temp_file(file_content: bytes):
         temp_file.flush()  # Ensure data is written
 
         # Get the file path for operations
-        return temp_file.name
+        return temp_file.name
+
+def file_to_bytes(filepath):
+    """
+    Reads a file and returns its content as a bytes object.
+
+    Args:
+        filepath (str): The path to the file.
+
+    Returns:
+        bytes: The content of the file as a bytes object.
+    """
+    try:
+        with open(filepath, "rb") as f:
+            file_content_bytes = f.read()
+        return file_content_bytes
+    except FileNotFoundError:
+        logger.error(f"File not found: {filepath}")
+        return None
+    except Exception as e:
+        logger.error(f"Error reading file {filepath}: {e}")
+        return None

alita_sdk/runtime/toolkits/configurations.py

@@ -0,0 +1,4 @@
+from alita_sdk.configurations import get_configurations as alita_configurations
+
+def get_configurations():
+    return alita_configurations()

alita_sdk/tools/ado/__init__.py

@@ -10,13 +10,12 @@ def get_tools(tool_type, tool):
         # common
         "selected_tools": tool['settings'].get('selected_tools', []),
         "organization_url": tool['settings']['organization_url'],
-        "project": tool['settings'].get('project', None),
-        "token": tool['settings'].get('token', None),
+        "ado_configuration": tool['settings']['ado_configuration'],
         "limit": tool['settings'].get('limit', 5),
         "toolkit_name": tool.get('toolkit_name', ''),
         # indexer settings
         "llm": tool['settings'].get('llm', None),
-        "connection_string": tool['settings'].get('connection_string', None),
+        "pgvector_configuration": tool['settings'].get('pgvector_configuration', {}),
         "collection_name": tool['toolkit_name'],
         "doctype": 'doc',
         "embedding_model": "HuggingFaceEmbeddings",