codemie-sdk-python 0.1.1__py3-none-any.whl

codemie_sdk/services/workflow.py

@@ -0,0 +1,144 @@
+"""Workflow service implementation."""
+
+import json
+from typing import List, Optional
+
+from .workflow_execution import WorkflowExecutionService
+from ..models.common import PaginationParams
+from ..models.workflow import (
+    WorkflowCreateRequest,
+    WorkflowUpdateRequest,
+    Workflow,
+)
+from ..utils import ApiRequestHandler
+
+
+class WorkflowService:
+    """Service for managing CodeMie workflows."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the workflow service.
+
+        Args:
+            api_domain: Base URL for the CodeMie API
+            token: Authentication token
+            verify_ssl: Whether to verify SSL certificates
+        """
+        self._api = ApiRequestHandler(api_domain, token, verify_ssl)
+
+    def get_prebuilt(self) -> List[Workflow]:
+        """Get list of prebuilt workflows.
+
+        Returns:
+            List of prebuilt workflow templates
+        """
+        return self._api.get("/v1/workflows/prebuilt", List[Workflow])
+
+    def create_workflow(self, request: WorkflowCreateRequest) -> dict:
+        """Create a new workflow.
+
+        Args:
+            request: The workflow creation request containing required fields:
+                    - name: Name of the workflow
+                    - description: Description of the workflow
+                    - project: Project identifier
+                    - yaml_config: YAML configuration for the workflow
+                    Optional fields with defaults:
+                    - mode: WorkflowMode (defaults to SEQUENTIAL)
+                    - shared: bool (defaults to False)
+                    - icon_url: Optional URL for workflow icon
+
+        Returns:
+            Created WorkflowTemplate instance
+        """
+        return self._api.post("/v1/workflows", dict, json_data=request.model_dump())
+
+    def update(self, workflow_id: str, request: WorkflowUpdateRequest) -> dict:
+        """Update an existing workflow.
+
+        Args:
+            workflow_id: ID of the workflow to update
+            request: The workflow update request containing optional fields to update:
+                    - name: New name for the workflow
+                    - description: New description
+                    - yaml_config: New YAML configuration
+                    - mode: New workflow mode
+                    - shared: New sharing status
+                    - icon_url: New icon URL
+                    Only specified fields will be updated.
+
+        Returns:
+            Updated WorkflowTemplate instance
+        """
+        return self._api.put(
+            f"/v1/workflows/{workflow_id}",
+            dict,
+            json_data=request.model_dump(exclude_none=True),
+        )
+
+    def list(
+        self,
+        page: int = 0,
+        per_page: int = 10,
+        projects: Optional[List[str]] = None,
+    ) -> List[Workflow]:
+        """List workflows 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.
+            projects: Optional projects to filter by.
+
+        Returns:
+            List of Workflow objects containing workflow information and pagination metadata.
+
+        """
+
+        params = PaginationParams(page=page, per_page=per_page).to_dict()
+
+        filters = {}
+        if projects:
+            filters["project"] = projects
+        if filters:
+            params["filters"] = json.dumps(filters)
+
+        return self._api.get("/v1/workflows", List[Workflow], params=params)
+
+    def get(self, workflow_id: str) -> Workflow:
+        """Get workflow by ID.
+
+        Args:
+            workflow_id: The ID of the workflow to retrieve.
+
+        Returns:
+            Workflow object containing the workflow information.
+
+        Raises:
+            ApiError: If the workflow is not found or other API errors occur.
+        """
+        return self._api.get(f"/v1/workflows/id/{workflow_id}", Workflow)
+
+    def delete(self, workflow_id: str) -> dict:
+        """Delete a workflow by ID.
+
+        Args:
+            workflow_id: ID of the workflow to delete
+
+        Returns:
+            Deletion confirmation
+        """
+        return self._api.delete(f"/v1/workflows/{workflow_id}", dict)
+
+    def run(self, workflow_id: str, user_input: str = "") -> dict:
+        return self.executions(workflow_id).create(user_input)
+
+    def executions(self, workflow_id: str) -> WorkflowExecutionService:
+        """Get workflow execution service for the specified workflow.
+
+        Args:
+            workflow_id: ID of the workflow to manage executions for
+
+        Returns:
+            WorkflowExecutionService instance configured for the specified workflow
+        """
+        return WorkflowExecutionService(self._api, workflow_id)

codemie_sdk/services/workflow_execution.py

@@ -0,0 +1,102 @@
+"""Workflow execution service implementation."""
+
+from typing import List, Optional
+
+from ..models.common import PaginationParams
+from ..models.workflow import WorkflowExecution
+from ..utils import ApiRequestHandler
+
+
+class WorkflowExecutionService:
+    """Service for managing workflow executions."""
+
+    def __init__(self, api: ApiRequestHandler, workflow_id: str):
+        """Initialize the workflow execution service.
+
+        Args:
+            api: Request handler for API
+            workflow_id: ID of the workflow this service manages executions for
+        """
+        self._api = api
+        self._workflow_id = workflow_id
+
+    def list(
+        self,
+        page: int = 0,
+        per_page: int = 10,
+    ) -> List[WorkflowExecution]:
+        """List executions for the workflow 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 WorkflowExecutions  containing execution information.
+        """
+
+        params = PaginationParams(page=page, per_page=per_page).to_dict()
+        return self._api.get(
+            f"/v1/workflows/{self._workflow_id}/executions",
+            List[WorkflowExecution],
+            params=params,
+        )
+
+    def create(self, user_input: Optional[str] = "") -> dict:
+        """Create a new workflow execution.
+
+        Args:
+            user_input: Optional input data for the workflow execution.
+                       Defaults to None.
+
+        Returns:
+            dict: Created workflow execution details
+        """
+        payload = {"user_input": user_input}
+        return self._api.post(
+            f"/v1/workflows/{self._workflow_id}/executions", dict, json_data=payload
+        )
+
+    def get(self, execution_id: str) -> WorkflowExecution:
+        """Get workflow execution by ID.
+
+        Args:
+            execution_id: ID of the execution to retrieve
+
+        Returns:
+            dict: Workflow execution details
+        """
+        return self._api.get(
+            f"/v1/workflows/{self._workflow_id}/executions/{execution_id}",
+            WorkflowExecution,
+        )
+
+    def delete_all(self) -> dict:
+        """Delete all workflow executions."""
+        return self._api.delete(f"/v1/workflows/{self._workflow_id}/executions", dict)
+
+    def abort(self, execution_id: str) -> dict:
+        """Abort a running workflow execution.
+
+        Args:
+            execution_id: ID of the execution to abort
+
+        Returns:
+            dict: Updated workflow execution details
+        """
+        return self._api.put(
+            f"/v1/workflows/{self._workflow_id}/executions/{execution_id}/abort", dict
+        )
+
+    def resume(self, execution_id: str) -> dict:
+        """Resume an interrupted workflow execution.
+
+        Args:
+            execution_id: ID of the execution to resume
+
+        Returns:
+            dict: Updated workflow execution details
+        """
+        return self._api.put(
+            f"/v1/workflows/{self._workflow_id}/executions/{execution_id}/resume", dict
+        )

codemie_sdk/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utility modules for CodeMie SDK."""
+
+from .http import ApiRequestHandler
+
+__all__ = ["ApiRequestHandler"]

codemie_sdk/utils/http.py

@@ -0,0 +1,226 @@
+"""HTTP utilities for CodeMie SDK."""
+
+from typing import TypeVar, Type, Optional, Any, Union, Dict, List, get_origin, get_args
+from pydantic import BaseModel
+import requests
+import logging
+from functools import wraps
+
+T = TypeVar("T", bound=Union[BaseModel, List[BaseModel], dict])
+
+logger = logging.getLogger(__name__)
+
+
+def log_request(func):
+    """Decorator to log request details"""
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        method = kwargs.get("method", args[0] if args else None)
+        endpoint = kwargs.get("endpoint", args[1] if len(args) > 1 else None)
+        logger.debug(f"Making {method} request to {self._base_url}{endpoint}")
+
+        try:
+            result = func(self, *args, **kwargs)
+            logger.info(f"Successfully processed {method} request to {endpoint}")
+            return result
+        except Exception as e:
+            logger.error(f"Error during {method} request to {endpoint}: {str(e)}")
+            raise
+
+    return wrapper
+
+
+class ApiRequestHandler:
+    """Handles HTTP requests with consistent error handling and response parsing."""
+
+    def __init__(self, base_url: str, token: str, verify_ssl: bool = True):
+        """Initialize the API request handler.
+
+        Args:
+            base_url: Base URL for the API
+            token: Authentication token
+            verify_ssl: Whether to verify SSL certificates
+        """
+        self._base_url = base_url.rstrip("/")
+        self._token = token
+        self._verify_ssl = verify_ssl
+
+    def _get_headers(self) -> dict:
+        """Gets request headers with auth token."""
+        return {
+            "Authorization": f"Bearer {self._token}",
+            "Content-Type": "application/json",
+        }
+
+    def _parse_response(
+        self,
+        response: requests.Response,
+        response_model: Type[T],
+        wrap_response: bool = True,
+    ) -> T:
+        """Parse response data into model, handling both single models and lists.
+
+        Args:
+            response: Response from requests
+            response_model: Type to parse into (can be a single model or List[model])
+            wrap_response: Whether response is wrapped in 'data' field
+
+        Returns:
+            Parsed response object or list of objects
+        """
+        try:
+            response_data = response.json()
+            logger.debug(f"Received response with status {response.status_code}")
+            logger.debug(f"Response datasource_type: {type(response_data)}")
+
+            # Handle data wrapper for dict responses only
+            if wrap_response and isinstance(response_data, dict):
+                response_data = response_data.get("data", response_data)
+
+            # If response_model is dict, return raw data
+            if response_model is dict:
+                return response_data
+
+            # Handle List types
+            origin = get_origin(response_model)
+            if origin is list:
+                # Get the model class from List[Model]
+                model_class = get_args(response_model)[0]
+                if not isinstance(response_data, list):
+                    response_data = [response_data]
+                return [model_class.model_validate(item) for item in response_data]
+            else:
+                # Handle single model
+                return response_model.model_validate(response_data)
+
+        except ValueError as e:
+            logger.error(f"Failed to parse response: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error parsing response: {str(e)}")
+            raise
+
+    @log_request
+    def get(
+        self,
+        endpoint: str,
+        response_model: Type[T],
+        params: Optional[Dict[str, Any]] = None,
+        wrap_response: bool = True,
+    ) -> T:
+        """Makes a GET request and parses the response.
+
+        Args:
+            endpoint: API endpoint path
+            response_model: Pydantic model class or List[Model] for response
+            params: Query parameters
+            wrap_response: Whether response is wrapped in 'data' field
+
+        Returns:
+            Parsed response object or list of objects
+        """
+        if params:
+            logger.debug(f"Request params: {params}")
+        response = requests.get(
+            url=f"{self._base_url}{endpoint}",
+            headers=self._get_headers(),
+            params=params,
+            verify=self._verify_ssl,
+        )
+        response.raise_for_status()
+
+        return self._parse_response(response, response_model, wrap_response)
+
+    @log_request
+    def post(
+        self,
+        endpoint: str,
+        response_model: Type[T],
+        json_data: Optional[Dict[str, Any]] = None,
+        stream: bool = False,
+        wrap_response: bool = True,
+    ) -> Union[T, requests.Response]:
+        """Makes a POST request and parses the response.
+
+        Args:
+            endpoint: API endpoint path
+            response_model: Pydantic model class or List[Model] for response
+            json_data: JSON request body
+            stream: Whether to return streaming response
+            wrap_response: Whether response is wrapped in 'data' field
+
+        Returns:
+            Parsed response object/list or streaming response
+        """
+        if json_data:
+            logger.debug(f"Request body: {json_data}")
+
+        response = requests.post(
+            url=f"{self._base_url}{endpoint}",
+            headers=self._get_headers(),
+            json=json_data,
+            verify=self._verify_ssl,
+            stream=stream,
+        )
+        response.raise_for_status()
+
+        if stream:
+            return response
+
+        return self._parse_response(response, response_model, wrap_response)
+
+    @log_request
+    def put(
+        self,
+        endpoint: str,
+        response_model: Type[T],
+        json_data: Dict[str, Any],
+        params: Optional[Dict[str, Any]] = None,
+        wrap_response: bool = True,
+    ) -> T:
+        """Makes a PUT request and parses the response.
+
+        Args:
+            endpoint: API endpoint path
+            response_model: Pydantic model class or List[Model] for response
+            json_data: JSON request body
+            params: Query parameters
+            wrap_response: Whether response is wrapped in 'data' field
+
+        Returns:
+            Parsed response object or list of objects
+        """
+        logger.debug(f"Request body: {json_data}")
+        response = requests.put(
+            url=f"{self._base_url}{endpoint}",
+            headers=self._get_headers(),
+            json=json_data,
+            params=params,
+            verify=self._verify_ssl,
+        )
+        response.raise_for_status()
+        return self._parse_response(response, response_model, wrap_response)
+
+    @log_request
+    def delete(
+        self, endpoint: str, response_model: Type[T], wrap_response: bool = True
+    ) -> T:
+        """Makes a DELETE request and parses the response.
+
+        Args:
+            endpoint: API endpoint path
+            response_model: Pydantic model class or List[Model] for response
+            wrap_response: Whether response is wrapped in 'data' field
+
+        Returns:
+            Parsed response object or list of objects
+        """
+        response = requests.delete(
+            url=f"{self._base_url}{endpoint}",
+            headers=self._get_headers(),
+            verify=self._verify_ssl,
+        )
+        response.raise_for_status()
+
+        return self._parse_response(response, response_model, wrap_response)

codemie_sdk_python-0.1.1.dist-info/LICENSE

@@ -0,0 +1,19 @@
+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.1.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.1
+Name: codemie-sdk-python
+Version: 0.1.1
+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
+```

codemie_sdk_python-0.1.1.dist-info/RECORD

@@ -0,0 +1,28 @@
+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/exceptions.py,sha256=XoVPyognx-JmyVxLHkZPAcX1CMi1OoT1diBFJLU54so,1183
+codemie_sdk/models/assistant.py,sha256=hx3R1H7UPqRvmBFKL7PDwHdVcX_CbjUsju55tjVRVEo,5538
+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/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/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
+codemie_sdk/services/llm.py,sha256=0-e4_7RvLHs2giCyoQ5U4KDTh6p5VXgPKNxnDP9ZDFU,1100
+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/utils/__init__.py,sha256=BXAJJfAzO89-kMYvWWo9wSNhSbGgF3vB1In9sePFhMM,109
+codemie_sdk/utils/http.py,sha256=d2GRkd-OBrrrURfVLeD7SUGFsyB4k1anYz5LXX3o4H8,7525
+codemie_sdk_python-0.1.1.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+codemie_sdk_python-0.1.1.dist-info/METADATA,sha256=pHfmSlkVSpTP7Qb2ESgrpP4_jzvUxNeSF6FSt0E8_es,2633
+codemie_sdk_python-0.1.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+codemie_sdk_python-0.1.1.dist-info/RECORD,,

codemie_sdk_python-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any