alita-sdk 0.3.227__py3-none-any.whl → 0.3.229__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/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/runtime/toolkits/tools.py

@@ -75,7 +75,7 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                 llm=tool['settings'].get('llm'),
                 # indexer settings
                 connection_string=tool['settings'].get('connection_string', None),
-                collection_name=f"{tool.get('toolkit_name')}_{str(tool['id'])}",
+                collection_name=tool.get('toolkit_name'),
                 embedding_model=tool['settings'].get('embedding_model', None),
                 embedding_model_params=tool['settings'].get('embedding_model_params', None),
                 vectorstore_type="PGVector"

alita_sdk/tools/ado/__init__.py

@@ -15,13 +15,13 @@ def get_tools(tool_type, tool):
         "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),
-        "collection_name":str(tool['id']),
-        "doctype":'doc',
-        "embedding_model":"HuggingFaceEmbeddings",
-        "embedding_model_params":{"model_name": "sentence-transformers/all-MiniLM-L6-v2"},
-        "vectorstore_type":"PGVector"
+        "llm": tool['settings'].get('llm', None),
+        "connection_string": tool['settings'].get('connection_string', None),
+        "collection_name": tool['toolkit_name'],
+        "doctype": 'doc',
+        "embedding_model": "HuggingFaceEmbeddings",
+        "embedding_model_params": {"model_name": "sentence-transformers/all-MiniLM-L6-v2"},
+        "vectorstore_type": "PGVector"
     }
     if tool_type == 'ado_plans':
         return AzureDevOpsPlansToolkit().get_toolkit(**config_dict).get_tools()