codemie-sdk-python 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

codemie_sdk/client/client.py

@@ -51,6 +51,11 @@ class CodeMieClient:
         self._token: Optional[str] = None
         self._api_domain = codemie_api_domain.rstrip("/")
         self._verify_ssl = verify_ssl
+        if not verify_ssl:
+            import requests
+            from urllib3.exceptions import InsecureRequestWarning
+
+            requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
 
         # Initialize token first
         self._token = self.auth.get_token()

codemie_sdk/models/assistant.py

@@ -11,6 +11,28 @@ from .common import User
 from .integration import Integration
 
 
+class GitToolName(str, Enum):
+    """Enum for Git tool names."""
+
+    LIST_BRANCHES_IN_REPO = "list_branches_in_repo"
+    CREATE_BRANCH = "create_branch"
+    SET_ACTIVE_BRANCH = "set_active_branch"
+    CREATE_FILE = "create_file"
+    UPDATE_FILE = "update_file"
+    UPDATE_FILE_DIFF = "update_file_diff"
+    DELETE_FILE = "delete_file"
+    CREATE_PULL_REQUEST = "create_pull_request"
+    GET_PR_CHANGES = "get_pr_changes"
+    CREATE_PR_CHANGES_COMMENT = "create_pr_changes_comment"
+
+
+class VcsToolName(str, Enum):
+    """Enum for VCS tool names."""
+
+    GITLAB = "gitlab"
+    GITHUB = "github"
+
+
 class ToolDetails(BaseModel):
     """Model for tool details."""
 
@@ -23,6 +45,13 @@ class ToolDetails(BaseModel):
     settings: Optional[Integration] = None
 
 
+class Toolkit(str, Enum):
+    """Enum for toolkits."""
+
+    GIT = "Git"
+    VCS = "VCS"
+
+
 class ToolKitDetails(BaseModel):
     """Model for toolkit details."""
 
@@ -149,7 +178,7 @@ class AssistantChatRequest(BaseModel):
     conversation_id: Optional[str] = Field(
         default=str(uuid.uuid4()), description="Conversation identifier"
     )
-    text: Optional[str] = Field(default=None, description="User's input error_message")
+    text: str = Field(description="User's input")
     content_raw: Optional[str] = Field(default="", description="Raw content input")
     file_name: Optional[str] = Field(default=None, description="Associated file name")
     llm_model: Optional[str] = Field(
@@ -166,6 +195,9 @@ class AssistantChatRequest(BaseModel):
     top_k: int = Field(default=10, description="Top K results to consider")
     system_prompt: str = Field(default="", description="Override system prompt")
     background_task: bool = Field(default=False, description="Run as background task")
+    metadata: Optional[dict[str, Any]] = Field(
+        default=None, description="Provide additional metadata"
+    )
 
 
 class BaseModelResponse(BaseModel):

codemie_sdk/models/datasource.py

@@ -1,7 +1,7 @@
 import re
 from datetime import datetime
 from enum import Enum
-from typing import Optional, List
+from typing import Optional, List, Union
 
 from pydantic import BaseModel, Field, model_validator, ConfigDict, field_validator
 
@@ -20,6 +20,10 @@ class DataSourceType(str, Enum):
     JIRA = "knowledge_base_jira"
     FILE = "knowledge_base_file"
     GOOGLE = "llm_routing_google"
+    PROVIDER = "provider"
+    SUMMARY = "summary"
+    CHUNK_SUMMARY = "chunk-summary"
+    JSON = "knowledge_base_json"
 
 
 class DataSourceStatus(str, Enum):
@@ -37,7 +41,7 @@ class DataSourceProcessingInfo(BaseModel):
     total_size_kb: Optional[float] = None
     average_file_size_bytes: Optional[float] = None
     unique_extensions: Optional[List[str]] = None
-    filtered_documents: Optional[int] = None
+    filtered_documents: Optional[Union[int, list]] = None
     processed_documents_count: Optional[int] = Field(None, alias="documents_count_key")
 
 

codemie_sdk/models/integration.py

@@ -1,10 +1,10 @@
 """Models for assistant-related data structures."""
 
-from datetime import datetime
 from enum import Enum
 from typing import List, Optional, Any
+from datetime import datetime
 
-from pydantic import BaseModel, Field, ConfigDict
+from pydantic import BaseModel, Field, ConfigDict, field_serializer
 
 
 class CredentialTypes(str, Enum):
@@ -33,6 +33,8 @@ class CredentialTypes(str, Enum):
     ZEPHYR_SQUAD = "ZephyrSquad"
     SERVICE_NOW = "ServiceNow"
     DIAL = "DIAL"
+    A2A = "A2A"
+    MCP = "MCP"
 
 
 class IntegrationType(str, Enum):
@@ -66,3 +68,7 @@ class Integration(BaseModel):
     credential_type: CredentialTypes
     credential_values: List[CredentialValues]
     setting_type: IntegrationType = Field(default=IntegrationType.USER)
+
+    @field_serializer("date", "update_date")
+    def serialize_dt(self, dt: datetime, _info):
+        return dt.isoformat()

codemie_sdk/models/workflow_state.py

@@ -0,0 +1,51 @@
+"""Workflow execution state models."""
+
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class WorkflowExecutionStatusEnum(str, Enum):
+    """Workflow execution state status."""
+
+    IN_PROGRESS = "In Progress"
+    NOT_STARTED = "Not Started"
+    INTERRUPTED = "Interrupted"
+    FAILED = "Failed"
+    SUCCEEDED = "Succeeded"
+    ABORTED = "Aborted"
+
+
+class WorkflowExecutionStateThought(BaseModel):
+    """Model for workflow execution state thought."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str
+    text: str
+    created_at: datetime
+    parent_id: Optional[str] = None
+
+
+class WorkflowExecutionState(BaseModel):
+    """Model for workflow execution state."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str
+    execution_id: str
+    name: str
+    task: Optional[str] = ""
+    status: WorkflowExecutionStatusEnum = WorkflowExecutionStatusEnum.NOT_STARTED
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+
+
+class WorkflowExecutionStateOutput(BaseModel):
+    """Model for workflow execution state output."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    output: Optional[str] = None

codemie_sdk/services/workflow_execution.py

@@ -4,6 +4,7 @@ from typing import List, Optional
 
 from ..models.common import PaginationParams
 from ..models.workflow import WorkflowExecution
+from .workflow_execution_state import WorkflowExecutionStateService
 from ..utils import ApiRequestHandler
 
 
@@ -71,6 +72,17 @@ class WorkflowExecutionService:
             WorkflowExecution,
         )
 
+    def states(self, execution_id: str) -> WorkflowExecutionStateService:
+        """Get states service for a specific workflow execution.
+
+        Args:
+            execution_id: ID of the execution to get states for
+
+        Returns:
+            WorkflowExecutionStateService: Service for managing states of this execution
+        """
+        return WorkflowExecutionStateService(self._api, self._workflow_id, execution_id)
+
     def delete_all(self) -> dict:
         """Delete all workflow executions."""
         return self._api.delete(f"/v1/workflows/{self._workflow_id}/executions", dict)

codemie_sdk/services/workflow_execution_state.py

@@ -0,0 +1,61 @@
+"""Workflow execution state service implementation."""
+
+from typing import List
+
+from ..models.common import PaginationParams
+from ..models.workflow_state import (
+    WorkflowExecutionState,
+    WorkflowExecutionStateOutput,
+)
+from ..utils import ApiRequestHandler
+
+
+class WorkflowExecutionStateService:
+    """Service for managing workflow execution states."""
+
+    def __init__(self, api: ApiRequestHandler, workflow_id: str, execution_id: str):
+        """Initialize the workflow execution state service.
+
+        Args:
+            api: Request handler for API
+            workflow_id: ID of the workflow this service manages states for
+            execution_id: ID of the execution this service manages states for
+        """
+        self._api = api
+        self._workflow_id = workflow_id
+        self._execution_id = execution_id
+
+    def list(
+        self,
+        page: int = 0,
+        per_page: int = 10,
+    ) -> List[WorkflowExecutionState]:
+        """List states for the workflow execution with filtering and pagination support.
+
+        Args:
+            page: Page number (0-based). Must be >= 0. Defaults to 0.
+            per_page: Number of items per page. Must be > 0. Defaults to 10.
+
+        Returns:
+            List of WorkflowExecutionState containing state information.
+        """
+        params = PaginationParams(page=page, per_page=per_page).to_dict()
+        return self._api.get(
+            f"/v1/workflows/{self._workflow_id}/executions/{self._execution_id}/states",
+            List[WorkflowExecutionState],
+            params=params,
+        )
+
+    def get_output(self, state_id: str) -> WorkflowExecutionStateOutput:
+        """Get output for a specific execution state.
+
+        Args:
+            state_id: ID of the state to get output for
+
+        Returns:
+            WorkflowExecutionStateOutput containing the state output.
+        """
+        return self._api.get(
+            f"/v1/workflows/{self._workflow_id}/executions/{self._execution_id}/states/{state_id}/output",
+            WorkflowExecutionStateOutput,
+        )

codemie_sdk/utils/http.py

@@ -48,10 +48,16 @@ class ApiRequestHandler:
 
     def _get_headers(self) -> dict:
         """Gets request headers with auth token."""
-        return {
-            "Authorization": f"Bearer {self._token}",
-            "Content-Type": "application/json",
-        }
+        headers = {"Content-Type": "application/json"}
+        if (
+            "0.0.0.0" in self._base_url
+            or "127.0.0.1" in self._base_url
+            or "localhost" in self._base_url
+        ):
+            headers["User-Id"] = "dev-codemie-user"
+        else:
+            headers["Authorization"] = f"Bearer {self._token}"
+        return headers
 
     def _parse_response(
         self,

codemie_sdk_python-0.1.6.dist-info/METADATA

@@ -0,0 +1,802 @@
+Metadata-Version: 2.1
+Name: codemie-sdk-python
+Version: 0.1.6
+Summary: CodeMie SDK for Python
+Author: Vadym Vlasenko
+Author-email: vadym_vlasenko@epam.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pydantic (>=2.11.1,<3.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+# CodeMie Python SDK
+
+Python SDK for CodeMie services. This SDK provides a comprehensive interface to interact with CodeMie services, including LLM (Large Language Models), assistants, workflows, and tools.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Basic Usage](#basic-usage)
+- [Service Details](#service-details)
+  - [LLM Service](#llm-service)
+  - [Assistant Service](#assistant-service)
+    - [Core Methods](#core-methods)
+    - [Advanced Features](#advanced-features)
+  - [Datasource Service](#datasource-service)
+    - [Supported Datasource Types](#supported-datasource-types)
+    - [Core Methods](#core-methods-1)
+    - [Datasource Status](#datasource-status)
+    - [Best Practices for Datasources](#best-practices-for-datasources)
+  - [Integration Service](#integration-service)
+    - [Integration Types](#integration-types)
+    - [Core Methods](#core-methods-2)
+    - [Best Practices for Integrations](#best-practices-for-integrations)
+  - [Workflow Service](#workflow-service)
+    - [Core Methods](#core-methods-3)
+    - [Workflow Execution](#workflow-execution)
+    - [Workflow Configuration](#workflow-configuration)
+    - [Best Practices](#best-practices)
+    - [Error Handling](#error-handling)
+    - [Workflow Status Monitoring](#workflow-status-monitoring)
+- [Development](#development)
+  - [Setup](#setup)
+  - [Running Tests](#running-tests)
+  - [Building Package](#building-package)
+- [Error Handling](#error-handling-1)
+- [Authentication](#authentication)
+  - [Required Parameters](#required-parameters)
+  - [Usage Examples](#usage-examples)
+- [Best Practices](#best-practices-1)
+- [Support](#support)
+
+## Installation
+
+```sh
+pip install codemie-sdk
+```
+
+## Usage
+
+### Basic usage
+
+```python
+from codemie_sdk import CodeMieClient
+
+# Initialize client with authentication parameters
+client = CodeMieClient(
+    auth_server_url="https://keycloak.eks-core.aws.main.edp.projects.epam.com/auth",
+    auth_client_id="your-client-id",
+    auth_client_secret="your-client-secret",
+    auth_realm_name="your-realm",
+    codemie_api_domain="https://codemie.lab.epam.com/code-assistant-api"
+)
+```
+
+## Service Details
+
+### LLM Service
+
+The LLM service provides access to language models and embedding models:
+
+- **list()**: Retrieves a list of available LLM models
+  ```python
+  llm_models = client.llm.list(token=client.token)
+  ```
+
+- **list_embeddings()**: Retrieves a list of available embedding models
+  ```python
+  embedding_models = client.llm.list_embeddings(token=client.token)
+  ```
+
+Each LLM model contains the following information:
+- Model identifier
+- Model capabilities
+- Configuration parameters
+
+Example usage:
+```python
+# List available LLM models
+llm_models = client.llm.list(token=client.token)
+
+# List available embedding models
+embedding_models = client.llm.list_embeddings(token=client.token)
+```
+
+### Assistant Service
+
+The Assistant service allows you to manage and interact with CodeMie assistants:
+
+#### Core Methods
+
+1. **List Assistants**
+```python
+assistants = client.assistant.list(
+    minimal_response=True,  # Return minimal assistant info
+    scope="visible_to_user",  # or "created_by_user"
+    page=0,
+    per_page=12,
+    filters={"key": "value"}  # Optional filters
+)
+```
+
+2. **Get Assistant Details**
+```python
+# By ID
+assistant = client.assistant.get("assistant-id")
+
+# By Slug
+assistant = client.assistant.get_by_slug("assistant-slug")
+```
+
+3. **Create Assistant**
+```python
+from codemie_sdk.models.assistant import AssistantCreateRequest
+
+request = AssistantCreateRequest(
+    name="My Assistant",
+    description="Assistant description",
+    instructions="Assistant instructions",
+    tools=["tool1", "tool2"],
+    # Additional parameters as needed
+)
+new_assistant = client.assistant.create(request)
+```
+
+4. **Update Assistant**
+```python
+from codemie_sdk.models.assistant import AssistantUpdateRequest
+
+request = AssistantUpdateRequest(
+    name="Updated Name",
+    description="Updated description",
+    # Other fields to update
+)
+updated_assistant = client.assistant.update("assistant-id", request)
+```
+
+5. **Delete Assistant**
+```python
+result = client.assistant.delete("assistant-id")
+```
+
+#### Advanced Features
+
+6. **Chat with Assistant**
+```python
+from codemie_sdk.models.assistant import AssistantChatRequest
+
+chat_request = AssistantChatRequest(
+    text="Your message here",
+    stream=False,  # Set to True for streaming response
+    # Additional parameters
+)
+response = client.assistant.chat("assistant-id", chat_request)
+```
+
+7. **Work with Prebuilt Assistants**
+```python
+# List prebuilt assistants
+prebuilt = client.assistant.get_prebuilt()
+
+# Get specific prebuilt assistant
+prebuilt_assistant = client.assistant.get_prebuilt_by_slug("assistant-slug")
+```
+
+8. **Get Available Tools**
+```python
+tools = client.assistant.get_tools()
+```
+
+### Datasource Service
+
+The Datasource service enables managing various types of data sources in CodeMie, including code repositories, Confluence spaces, Jira projects, files, and Google documents.
+
+#### Supported Datasource Types
+
+- `CODE`: Code repository datasources
+- `CONFLUENCE`: Confluence knowledge base
+- `JIRA`: Jira knowledge base
+- `FILE`: File-based knowledge base
+- `GOOGLE`: Google documents
+
+#### Core Methods
+
+1. **Create Datasource**
+```python
+from codemie_sdk.models.datasource import (
+    CodeDataSourceRequest,
+    ConfluenceDataSourceRequest,
+    JiraDataSourceRequest,
+    GoogleDataSourceRequest
+)
+
+# Create Code Datasource
+code_request = CodeDataSourceRequest(
+    name="my_repo",  # lowercase letters and underscores only
+    project_name="my_project",
+    description="My code repository",
+    link="https://github.com/user/repo",
+    branch="main",
+    index_type="code",  # or "summary" or "chunk-summary"
+    files_filter="*.py",  # optional
+    embeddings_model="model_name",
+    summarization_model="gpt-4",  # optional
+    docs_generation=False  # optional
+)
+result = client.datasource.create(code_request)
+
+# Create Confluence Datasource
+confluence_request = ConfluenceDataSourceRequest(
+    name="confluence_kb",
+    project_name="my_project",
+    description="Confluence space",
+    cql="space = 'MYSPACE'",
+    include_restricted_content=False,
+    include_archived_content=False,
+    include_attachments=True,
+    include_comments=True
+)
+result = client.datasource.create(confluence_request)
+
+# Create Jira Datasource
+jira_request = JiraDataSourceRequest(
+    name="jira_kb",
+    project_name="my_project",
+    description="Jira project",
+    jql="project = 'MYPROJECT'"
+)
+result = client.datasource.create(jira_request)
+
+# Create Google Doc Datasource
+google_request = GoogleDataSourceRequest(
+    name="google_doc",
+    project_name="my_project",
+    description="Google document",
+    google_doc="document_url"
+)
+result = client.datasource.create(google_request)
+```
+
+2. **Update Datasource**
+```python
+from codemie_sdk.models.datasource import UpdateCodeDataSourceRequest
+
+# Update Code Datasource
+update_request = UpdateCodeDataSourceRequest(
+    name="my_repo",
+    project_name="my_project",
+    description="Updated description",
+    branch="develop",
+    full_reindex=True,  # optional reindex parameters
+    skip_reindex=False,
+    resume_indexing=False
+)
+result = client.datasource.update("datasource_id", update_request)
+```
+
+3. **List Datasources**
+```python
+# List all datasources with filtering and pagination
+datasources = client.datasource.list(
+    page=0,
+    per_page=10,
+    sort_key="update_date",  # or "date"
+    sort_order="desc",  # or "asc"
+    datasource_types=["CODE", "CONFLUENCE"],  # optional filter by type
+    projects=["project1", "project2"],  # optional filter by projects
+    owner="John Doe",  # optional filter by owner
+    status="COMPLETED"  # optional filter by status
+)
+```
+
+4. **Get Datasource Details**
+```python
+# Get single datasource by ID
+datasource = client.datasource.get("datasource_id")
+```
+
+5. **Delete Datasource**
+```python
+# Delete datasource by ID
+result = client.datasource.delete("datasource_id")
+```
+
+#### Datasource Status
+
+Datasources can have the following statuses:
+- `COMPLETED`: Indexing completed successfully
+- `FAILED`: Indexing failed
+- `FETCHING`: Fetching data from source
+- `IN_PROGRESS`: Processing/indexing in progress
+
+#### Best Practices for Datasources
+
+1. **Naming Convention**:
+   - Use lowercase letters and underscores for datasource names
+   - Keep names descriptive but concise
+
+2. **Performance Optimization**:
+   - Use appropriate filters when listing datasources
+   - Consider pagination for large result sets
+   - Choose appropriate reindex options based on your needs
+
+3. **Error Handling**:
+   - Always check datasource status after creation/update
+   - Handle potential failures gracefully
+   - Monitor processing information for issues
+
+4. **Security**:
+   - Be careful with sensitive data in filters and queries
+   - Use proper access controls when sharing datasources
+   - Regularly review and clean up unused datasources
+
+### Integration Service
+
+The Integration service manages both user and project-level integrations in CodeMie, allowing you to configure and manage various integration settings.
+
+#### Integration Types
+
+- `USER`: User-level integrations
+- `PROJECT`: Project-level integrations
+
+#### Core Methods
+
+1. **List Integrations**
+```python
+from codemie_sdk.models.integration import IntegrationType
+
+# List user integrations with pagination
+user_integrations = client.integration.list(
+    setting_type=IntegrationType.USER,
+    page=0,
+    per_page=10,
+    filters={"some_filter": "value"}  # optional
+)
+
+# List project integrations
+project_integrations = client.integration.list(
+    setting_type=IntegrationType.PROJECT,
+    per_page=100
+)
+```
+
+2. **Get Integration**
+```python
+# Get integration by ID
+integration = client.integration.get(
+    integration_id="integration_id",
+    setting_type=IntegrationType.USER
+)
+
+# Get integration by alias
+integration = client.integration.get_by_alias(
+    alias="integration_alias",
+    setting_type=IntegrationType.PROJECT
+)
+```
+
+3. **Create Integration**
+```python
+from codemie_sdk.models.integration import Integration
+
+# Create new integration
+new_integration = Integration(
+    setting_type=IntegrationType.USER,
+    alias="my_integration",
+    # Add other required fields based on integration type
+)
+result = client.integration.create(new_integration)
+```
+
+4. **Update Integration**
+```python
+# Update existing integration
+updated_integration = Integration(
+    setting_type=IntegrationType.USER,
+    alias="updated_alias",
+    # Add other fields to update
+)
+result = client.integration.update("integration_id", updated_integration)
+```
+
+5. **Delete Integration**
+```python
+# Delete integration
+result = client.integration.delete(
+    setting_id="integration_id",
+    setting_type=IntegrationType.USER
+)
+```
+
+#### Best Practices for Integrations
+
+1. **Error Handling**:
+   - Handle `NotFoundError` when getting integrations by ID or alias
+   - Validate integration settings before creation/update
+   - Use appropriate setting type (USER/PROJECT) based on context
+
+2. **Performance**:
+   - Use pagination for listing integrations
+   - Cache frequently accessed integrations when appropriate
+   - Use filters to reduce result set size
+
+3. **Security**:
+   - Keep integration credentials secure
+   - Regularly review and update integration settings
+   - Use project-level integrations for team-wide settings
+   - Use user-level integrations for personal settings
+
+### Workflow Service
+
+The Workflow service enables you to create, manage, and execute workflows in CodeMie. Workflows allow you to automate complex processes and integrate various CodeMie services.
+
+#### Core Methods
+
+1. **Create Workflow**
+```python
+from codemie_sdk.models.workflow import WorkflowCreateRequest
+
+# Create new workflow
+workflow_request = WorkflowCreateRequest(
+    name="My Workflow",
+    description="Workflow description",
+    project="project-id",
+    yaml_config="your-yaml-configuration",
+    mode="SEQUENTIAL",  # Optional, defaults to SEQUENTIAL
+    shared=False,       # Optional, defaults to False
+    icon_url="https://example.com/icon.png"  # Optional
+)
+result = client.workflow.create_workflow(workflow_request)
+```
+
+2. **Update Workflow**
+```python
+from codemie_sdk.models.workflow import WorkflowUpdateRequest
+
+# Update existing workflow
+update_request = WorkflowUpdateRequest(
+    name="Updated Workflow",
+    description="Updated description",
+    yaml_config="updated-yaml-config",
+    mode="PARALLEL",
+    shared=True
+)
+result = client.workflow.update("workflow-id", update_request)
+```
+
+3. **List Workflows**
+```python
+# List workflows with pagination and filtering
+workflows = client.workflow.list(
+    page=0,
+    per_page=10,
+    projects=["project1", "project2"]  # Optional project filter
+)
+```
+
+4. **Get Workflow Details**
+```python
+# Get workflow by ID
+workflow = client.workflow.get("workflow-id")
+
+# Get prebuilt workflows
+prebuilt_workflows = client.workflow.get_prebuilt()
+```
+
+5. **Delete Workflow**
+```python
+result = client.workflow.delete("workflow-id")
+```
+
+#### Workflow Execution
+
+The SDK provides comprehensive workflow execution management through the WorkflowExecutionService:
+
+1. **Run Workflow**
+```python
+# Simple workflow execution
+execution = client.workflow.run("workflow-id", user_input="optional input")
+
+# Get execution service for advanced operations
+execution_service = client.workflow.executions("workflow-id")
+```
+
+2. **Manage Executions**
+```python
+# List workflow executions
+executions = execution_service.list(
+    page=0,
+    per_page=10
+)
+
+# Get execution details
+execution = execution_service.get("execution-id")
+
+# Abort running execution
+result = execution_service.abort("execution-id")
+
+# Resume interrupted execution
+result = execution_service.resume("execution-id")
+
+# Delete all executions
+result = execution_service.delete_all()
+```
+
+3. **Work with Execution States**
+```python
+# Get execution states
+states = execution_service.states(execution_id).list()
+
+# Get state output
+state_output = execution_service.states(execution_id).get_output(state_id)
+
+# Example of monitoring workflow with state verification
+def verify_workflow_execution(execution_service, execution_id):
+    execution = execution_service.get(execution_id)
+    
+    if execution.status == ExecutionStatus.SUCCEEDED:
+        # Get and verify states
+        states = execution_service.states(execution_id).list()
+        
+        # States are ordered by completion date
+        if len(states) >= 2:
+            first_state = states[0]
+            second_state = states[1]
+            assert first_state.completed_at < second_state.completed_at
+            
+            # Get state outputs
+            for state in states:
+                output = execution_service.states(execution_id).get_output(state.id)
+                print(f"State {state.id} output: {output.output}")
+    
+    elif execution.status == ExecutionStatus.FAILED:
+        print(f"Workflow failed: {execution.error_message}")
+```
+
+#### Workflow Configuration
+
+Workflows support various configuration options:
+
+1. **Modes**:
+- `SEQUENTIAL`: Tasks execute in sequence
+- `PARALLEL`: Tasks can execute simultaneously
+
+2. **YAML Configuration**:
+```yaml
+name: Example Workflow
+description: Workflow description
+tasks:
+  - name: task1
+    type: llm
+    config:
+      prompt: "Your prompt here"
+      model: "gpt-4"
+  
+  - name: task2
+    type: tool
+    config:
+      tool_name: "your-tool"
+      parameters:
+        param1: "value1"
+```
+
+#### Best Practices
+
+1. **Workflow Design**:
+- Keep workflows modular and focused
+- Use clear, descriptive names for workflows and tasks
+- Document workflow purpose and requirements
+- Test workflows thoroughly before deployment
+
+2. **Execution Management**:
+- Monitor long-running workflows
+- Implement proper error handling
+- Use pagination for listing executions
+- Clean up completed executions regularly
+
+3. **Performance Optimization**:
+- Choose appropriate workflow mode (SEQUENTIAL/PARALLEL)
+- Manage resource usage in parallel workflows
+- Consider task dependencies and ordering
+- Use efficient task configurations
+
+4. **Security**:
+- Control workflow sharing carefully
+- Validate user inputs
+- Manage sensitive data appropriately
+- Regular audit of workflow access
+
+5. **Maintenance**:
+- Regular review of workflow configurations
+- Update workflows when dependencies change
+- Monitor workflow performance
+- Archive or remove unused workflows
+
+#### Error Handling
+
+Implement proper error handling for workflow operations:
+
+```python
+try:
+    workflow = client.workflow.get("workflow-id")
+except ApiError as e:
+    if e.status_code == 404:
+        print("Workflow not found")
+    else:
+        print(f"API error: {e}")
+except Exception as e:
+    print(f"Unexpected error: {e}")
+```
+
+#### Workflow Status Monitoring
+
+Monitor workflow execution status:
+
+```python
+def monitor_execution(execution_service, execution_id):
+    while True:
+        execution = execution_service.get(execution_id)
+        status = execution.status
+        
+        if status == "COMPLETED":
+            print("Workflow completed successfully")
+            break
+        elif status == "FAILED":
+            print(f"Workflow failed: {execution.error}")
+            break
+        elif status == "ABORTED":
+            print("Workflow was aborted")
+            break
+            
+        time.sleep(5)  # Poll every 5 seconds
+```
+
+## Error Handling
+
+The SDK implements comprehensive error handling. All API calls may raise exceptions for:
+- Authentication failures
+- Network errors
+- Invalid parameters
+- Server-side errors
+
+It's recommended to implement try-catch blocks around SDK operations to handle potential exceptions gracefully.
+
+## Authentication
+
+The SDK supports two authentication methods through Keycloak:
+
+1. Username/Password Authentication
+2. Client Credentials Authentication
+
+### Required Parameters
+
+You must provide either:
+
+- Username/Password credentials:
+  ```python
+  {
+      "username": "your-username", 
+      "password": "your-password",
+      "auth_client_id": "client-id",        # Optional, defaults to "codemie-sdk"
+      "auth_realm_name": "realm-name",
+      "auth_server_url": "keycloak-url",
+      "verify_ssl": True                    # Optional, defaults to True
+  }
+  ```
+
+OR
+
+- Client Credentials:
+  ```python
+  {
+      "auth_client_id": "your-client-id",
+      "auth_client_secret": "your-client-secret",
+      "auth_realm_name": "realm-name", 
+      "auth_server_url": "keycloak-url",
+      "verify_ssl": True                    # Optional, defaults to True
+  }
+  ```
+
+### Usage Examples
+
+1. Username/Password Authentication:
+```python
+from codemie_sdk import CodeMieClient
+
+client = CodeMieClient(
+    codemie_api_domain="https://api.domain.com",
+    username="your-username",
+    password="your-password",
+    auth_client_id="your-client-id",        # Optional
+    auth_realm_name="your-realm",
+    auth_server_url="https://keycloak.domain.com/auth",
+    verify_ssl=True                         # Optional
+)
+```
+
+2. Client Credentials Authentication:
+```python
+from codemie_sdk.auth import KeycloakCredentials
+
+credentials = KeycloakCredentials(
+    server_url="https://keycloak.domain.com/auth",
+    realm_name="your-realm",
+    client_id="your-client-id",
+    client_secret="your-client-secret",
+    verify_ssl=True                         # Optional
+)
+
+client = CodeMieClient(
+    codemie_api_domain="https://api.domain.com",
+    credentials=credentials
+)
+```
+
+## Support
+For providing credentials please contact AI/Run CodeMie Team: Vadym_Vlasenko@epam.com or Nikita_Levyankov@epam.com
+
+## Running tests
+
+For running tests on custom environment you should create .env file in the root directory
+
+``` properties
+
+AUTH_SERVER_URL=https://keycloak.eks-core.aws.main.edp.projects.epam.com/auth
+AUTH_CLIENT_ID=codemie-preview
+AUTH_CLIENT_SECRET=<your_secret>
+AUTH_REALM_NAME=codemie-prod
+CODEMIE_API_DOMAIN=https://codemie-preview.lab.epam.com/code-assistant-api
+VERIFY_SSL=False
+
+USERNAME=<username>
+PASSWORD=<password>
+
+PROJECT_NAME=automation-tests-project
+
+DEFAULT_TIMEOUT=60
+
+GITLAB_URL=https://gitbud.epam.com
+GITLAB_TOKEN=<gitlab_token>
+GITLAB_PROJECT=https://gitbud.epam.com/epm-cdme/autotests/codemie-test-project
+GITLAB_PROJECT_ID=<project_id>
+
+GITHUB_URL=https://github.com
+GITHUB_TOKEN=<github_token>
+GITHUB_PROJECT=https://github.com/wild47/final_task
+
+JIRA_URL=https://jiraeu.epam.com
+JIRA_TOKEN=<jira_token>
+JQL="project = 'EPMCDME' and issuetype = 'Epic' and status = 'Closed'"
+
+CONFLUENCE_URL=https://kb.epam.com
+CONFLUENCE_TOKEN=<konfluence_token>
+CQL="space = EPMCDME and type = page and title = 'AQA Backlog Estimation'"
+```
+
+Run all tests
+
+```shell
+pytest -n auto --reruns 1
+```
+
+Run e2e tests
+
+```shell
+pytest -n auto -m e2e --reruns 1
+```
+
+Run tests for e2e tests for specific integration/tool.
+Available marks:
+ - jira_kb
+ - confluence_kb
+ - code_kb
+ - gitlab
+ - github
+ - git
+
+```shell
+pytest -n auto -m "jira_kb or github" --reruns 1
+```

{codemie_sdk_python-0.1.4.dist-info → codemie_sdk_python-0.1.6.dist-info}/RECORD

@@ -2,16 +2,17 @@ codemie_sdk/__init__.py,sha256=xfhrTFdvRmLSsrdQksX5GhnoQEj6tvkeytkrbB20Jj8,567
 codemie_sdk/auth/__init__.py,sha256=IksEj223xEZtJ-cQ0AT9L0Bs9psIJ8QNzDXrPTUQ3xQ,126
 codemie_sdk/auth/credentials.py,sha256=u2eLNsD8fELTgreQghVb0g0kk82zchUkux0M5lzq-u8,4320
 codemie_sdk/client/__init__.py,sha256=yf6C39MmrJ6gK9ZHMhBeynKwUUYVSUTQbKxU8-4qpKg,101
-codemie_sdk/client/client.py,sha256=aU4yr_Un4gX7SLXZ7rQiO_ObxE2__RyR8OdlxeKLRvc,4172
+codemie_sdk/client/client.py,sha256=dVcWqd-ruWd8GOZ3_33C3LnHgUyyxIoCKxKYPYbBPq8,4373
 codemie_sdk/exceptions.py,sha256=XoVPyognx-JmyVxLHkZPAcX1CMi1OoT1diBFJLU54so,1183
-codemie_sdk/models/assistant.py,sha256=hx3R1H7UPqRvmBFKL7PDwHdVcX_CbjUsju55tjVRVEo,5538
+codemie_sdk/models/assistant.py,sha256=5VT5DOUPsEjVTLEPQoxFw5yna0BDoJBq0D8daVIp7l4,6304
 codemie_sdk/models/common.py,sha256=V4sJCzwFTF8BPlrd2OKI44Em5HmPmn2Nm8fQNsnBZ_Q,1128
-codemie_sdk/models/datasource.py,sha256=Kjde8pXi4pm6x37g-c838C3yDg4tnTJHNvITA3rvmUk,9898
-codemie_sdk/models/integration.py,sha256=lhY_5Dxm0MDxp9vxL0H0HaM-ytNNoyBSOoEYTw4a-rU,1589
+codemie_sdk/models/datasource.py,sha256=Iun6O76o4m-_jbyyumMndpyr4OiN0lwqKb8u5AOTHdM,10037
+codemie_sdk/models/integration.py,sha256=F1YBdCK1w5W_jKK8prEsg7A00NghkEBvJgkkr8KpC6w,1764
 codemie_sdk/models/llm.py,sha256=ppb9-1dx1UFhRuJpSR3ij7H6Pfhe9nO4C4BEOIbToy4,1192
 codemie_sdk/models/task.py,sha256=J4ZFRY3s8qBGrqB5NLQF0rMbInLh4s7OEZ0ZfmnW0Ho,1476
 codemie_sdk/models/user.py,sha256=Q0rjimZh-IbeaPfq6b6fk6ZaCtwLqWHEIlU863suCS4,1777
 codemie_sdk/models/workflow.py,sha256=CyK-kBnOck2KiRX3gmWF_mcGtqxsGXH3FS3jwYbpz_A,2327
+codemie_sdk/models/workflow_state.py,sha256=CMYFQZ7sy4QxmnWmc83TFfqP7TG_3rW5MdH5fxsS9kY,1251
 codemie_sdk/services/assistant.py,sha256=-U5YpqOyKlVplSRPrnDItG8TUpg9qqhO6-F7c7Rz2xU,5110
 codemie_sdk/services/datasource.py,sha256=hYH__M5LD33dfh7CCS7HYmEn8izsGkO0nfVa-dpoj6w,5118
 codemie_sdk/services/integration.py,sha256=vJnSkXk2C2l0ahX2SUsuA7fKhY2hTuAByynx5Lgh7Ls,4864
@@ -19,10 +20,10 @@ codemie_sdk/services/llm.py,sha256=0-e4_7RvLHs2giCyoQ5U4KDTh6p5VXgPKNxnDP9ZDFU,1
 codemie_sdk/services/task.py,sha256=3e9t8_LMkR4xfeMBwMCo7ZF87PxPS-ZbzDg85ilda2M,1031
 codemie_sdk/services/user.py,sha256=7B-Qw451qKPD5Io6qLda-kbFDaPRQ3TamJamiGwCQu4,1013
 codemie_sdk/services/workflow.py,sha256=aOV13WrFAqMXOPd2jVHbEhg3fpezk4XWo382D5aWtro,4833
-codemie_sdk/services/workflow_execution.py,sha256=Ud-cYC_a2yb3FErfwWjM7hBIHzs2QoYQ-kX-o7K1cms,3152
+codemie_sdk/services/workflow_execution.py,sha256=aGoT3rdTmh5-doAsrmBBjLEuOfvL5aqeo3g9th1_aAw,3647
+codemie_sdk/services/workflow_execution_state.py,sha256=tXoaa8yT09xgYEUNiHhVULe76TwGwVgZupMIUyyLxdo,2070
 codemie_sdk/utils/__init__.py,sha256=BXAJJfAzO89-kMYvWWo9wSNhSbGgF3vB1In9sePFhMM,109
-codemie_sdk/utils/http.py,sha256=d2GRkd-OBrrrURfVLeD7SUGFsyB4k1anYz5LXX3o4H8,7525
-codemie_sdk_python-0.1.4.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-codemie_sdk_python-0.1.4.dist-info/METADATA,sha256=6r74NCBL8fKOBHzSeC6xARrOwqWd-VvfkzjvYaUJung,2633
-codemie_sdk_python-0.1.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-codemie_sdk_python-0.1.4.dist-info/RECORD,,
+codemie_sdk/utils/http.py,sha256=JfyX4gP-grQUI795QL0DJ72aBkiqNd1fs31fUqtSnYE,7757
+codemie_sdk_python-0.1.6.dist-info/METADATA,sha256=bFS58qIKO7ZXcvu_L3QilTaE9tEV8hh8gQt4x-sqT6I,21439
+codemie_sdk_python-0.1.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+codemie_sdk_python-0.1.6.dist-info/RECORD,,

codemie_sdk_python-0.1.4.dist-info/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2018 The Python Packaging Authority
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

codemie_sdk_python-0.1.4.dist-info/METADATA

@@ -1,120 +0,0 @@
-Metadata-Version: 2.1
-Name: codemie-sdk-python
-Version: 0.1.4
-Summary: CodeMie SDK for Python
-Author: Vadym Vlasenko
-Author-email: vadym_vlasenko@epam.com
-Requires-Python: >=3.12,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: pydantic (>=2.6.1,<3.0.0)
-Requires-Dist: pytest-cov (>=6.0.0,<7.0.0)
-Requires-Dist: requests (>=2.31.0,<3.0.0)
-Requires-Dist: ruff (>=0.11.0,<0.12.0)
-Description-Content-Type: text/markdown
-
-# CodeMie Python SDK
-
-Python SDK for CodeMie services
-
-
-## Installation
-
-```sh
-pip install codemie-sdk
-```
-
-## Usage
-
-### Basic usage
-
-```python
-from codemie_sdk import CodeMieClient
-
-# Initialize client with authentication parameters
-client = CodeMieClient(
-    auth_server_url="https://keycloak.example.com",
-    auth_client_id="your-client-id",
-    auth_client_secret="your-client-secret",
-    auth_realm_name="your-realm",
-    codemie_api_domain="https://codemie-preview.lab.epam.com/code-assistant-api"
-)
-
-# Create a new workflow
-workflow = client.workflow.create('project-id', 'workflow-name', {'param': 'value'}, token=client.token)
-
-# Execute tool
-tool_result = client.tool.execute(
-    tool_name='my-tool',
-    project='project-id',
-    tool_args={'param': 'value'},
-    token=client.token
-)
-```
-
-### Tool Operations
-
-```python
-# List available tools
-tools = client.tool.list(token=client.token)
-
-# Get tool schema
-schema = client.tool.schema('tool-name', token=client.token)
-
-# Execute tool with optional parameters
-result = client.tool.execute(
-    tool_name='my-tool',
-    project='project-id',
-    tool_args={'param': 'value'},
-    token=client.token,
-    llm_model='gpt-4',  # optional
-    tool_attributes={'attr': 'value'},  # optional
-    tool_creds={'cred': 'secret'},  # optional
-    datasource_id='ds-123',  # optional
-    params={'retry_count': 3}  # optional
-)
-```
-
-### Workflow Operations
-
-```python
-# Create workflow
-workflow = client.workflow.create('project-id', 'workflow-name', {'param': 'value'}, token=client.token)
-
-# Get workflow status
-status = client.workflow.status('workflow-id', token=client.token)
-
-# List workflows
-workflows = client.workflow.list('project-id', token=client.token)
-
-# Get workflow result
-result = client.workflow.result('workflow-id', token=client.token)
-```
-
-## Development
-
-### Setup
-
-1. Create and activate virtual environment:
-```sh
-python -m venv venv
-source venv/bin/activate  # Linux/MacOS
-venv\Scripts\activate     # Windows
-```
-
-2. Install dependencies:
-```sh
-pip install -r requirements.txt
-```
-
-### Running Tests
-
-```sh
-make test
-```
-
-### Building Package
-
-```sh
-make build
-```