codemie-sdk-python 0.1.1__tar.gz

codemie_sdk_python-0.1.1/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,105 @@
+# 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/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "codemie-sdk-python"
+version = "0.1.1"
+description = "CodeMie SDK for Python"
+authors = [
+    "Vadym Vlasenko <vadym_vlasenko@epam.com>",
+]
+readme = "README.md"
+packages = [
+    { include = "codemie_sdk", from = "src" }
+]
+
+[tool.poetry.dependencies]
+python = "^3.12"
+requests = "^2.31.0"
+pydantic = "^2.6.1"
+ruff = "^0.11.0"
+pytest-cov = "^6.0.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

codemie_sdk_python-0.1.1/src/codemie_sdk/__init__.py

@@ -0,0 +1,23 @@
+"""
+CodeMie SDK for Python
+~~~~~~~~~~~~~~~~~~~~~
+
+A Python SDK for interacting with CodeMie API.
+
+Basic usage:
+
+    >>> from codemie_sdk import CodeMieClient
+    >>> client = CodeMieClient(
+    ...     auth_server_url="https://auth.example.com",
+    ...     auth_client_id="client_id",
+    ...     auth_client_secret="secret",
+    ...     auth_realm_name="realm",
+    ...     codemie_api_domain="api.codemie.com"
+    ... )
+    >>> assistants = client.assistants.list()
+"""
+
+from .client.client import CodeMieClient
+
+__version__ = "0.1.11"
+__all__ = ["CodeMieClient"]

codemie_sdk_python-0.1.1/src/codemie_sdk/auth/__init__.py

@@ -0,0 +1,5 @@
+"""Authentication module for CodeMie SDK."""
+
+from .credentials import KeycloakCredentials
+
+__all__ = ["KeycloakCredentials"]

codemie_sdk_python-0.1.1/src/codemie_sdk/auth/credentials.py

@@ -0,0 +1,112 @@
+"""Authentication credentials module for CodeMie SDK."""
+
+import requests
+from typing import Optional
+
+
+class KeycloakCredentials:
+    """Keycloak authentication credentials handler."""
+
+    def __init__(
+        self,
+        server_url: str,
+        realm_name: str,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        verify_ssl: bool = True,
+    ):
+        """Initialize Keycloak credentials.
+
+        Args:
+            server_url: Keycloak server URL
+            realm_name: Realm name
+            client_id: Client ID (optional if using username/password)
+            client_secret: Client secret (optional if using username/password)
+            username: Username/email for password grant (optional)
+            password: Password for password grant (optional)
+            verify_ssl: Whether to verify SSL certificates (default: True)
+        """
+        self.server_url = server_url.rstrip("/")
+        self.realm_name = realm_name
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.username = username
+        self.password = password
+        self.verify_ssl = verify_ssl
+
+        if not ((client_id and client_secret) or (username and password)):
+            raise ValueError(
+                "Either client credentials (client_id, client_secret) or "
+                "user credentials (username, password) must be provided"
+            )
+
+    def get_token(self) -> str:
+        """Get access token using either client credentials or password grant."""
+        url = (
+            f"{self.server_url}/realms/{self.realm_name}/protocol/openid-connect/token"
+        )
+
+        if self.username and self.password:
+            # Use Resource Owner Password Credentials flow
+            payload = {
+                "grant_type": "password",
+                "username": self.username,
+                "password": self.password,
+                "client_id": self.client_id
+                or "codemie-sdk",  # Use default client if not specified
+            }
+            if self.client_secret:
+                payload["client_secret"] = self.client_secret
+        else:
+            # Use Client Credentials flow
+            payload = {
+                "grant_type": "client_credentials",
+                "client_id": self.client_id,
+                "client_secret": self.client_secret,
+            }
+
+        response = requests.post(url, data=payload, verify=self.verify_ssl)
+        response.raise_for_status()
+        return response.json()["access_token"]
+
+    def exchange_token_for_user(self, email: str, access_token: str) -> str:
+        """Exchange service account token for user token."""
+        user_id = self.find_user_by_email(email, access_token)
+        return self._exchange_token_for_user(user_id, access_token)
+
+    def find_user_by_email(self, email: str, access_token: str) -> str:
+        """Find user ID by email."""
+        url = f"{self.server_url}/admin/realms/{self.realm_name}/users?email={email}"
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+            "Content-Type": "application/json",
+        }
+        response = requests.get(url, headers=headers, verify=self.verify_ssl)
+        response.raise_for_status()
+
+        users = response.json()
+        if not users:
+            raise ValueError(f"User with email {email} not found")
+        return users[0]["id"]
+
+    def _exchange_token_for_user(self, user_id: str, service_account_token: str) -> str:
+        """Exchange token for specific user."""
+        url = (
+            f"{self.server_url}/realms/{self.realm_name}/protocol/openid-connect/token"
+        )
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        payload = {
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "grant_type": "urn:ietf:params:oauth:grant-datasource_type:token-exchange",
+            "subject_token": service_account_token,
+            "requested_subject": user_id,
+        }
+
+        response = requests.post(
+            url, headers=headers, data=payload, verify=self.verify_ssl
+        )
+        response.raise_for_status()
+        return response.json()["access_token"]

codemie_sdk_python-0.1.1/src/codemie_sdk/client/__init__.py

@@ -0,0 +1,5 @@
+"""Client module for CodeMie SDK."""
+
+from .client import CodeMieClient
+
+__all__ = ["CodeMieClient"]

codemie_sdk_python-0.1.1/src/codemie_sdk/client/client.py

@@ -0,0 +1,107 @@
+"""Base client implementation for CodeMie SDK."""
+
+from typing import Optional
+
+from ..auth.credentials import KeycloakCredentials
+from ..services.assistant import AssistantService
+from ..services.datasource import DatasourceService
+from ..services.llm import LLMService
+from ..services.integration import IntegrationService
+from ..services.task import TaskService
+from ..services.user import UserService
+from ..services.workflow import WorkflowService
+
+
+class CodeMieClient:
+    """Main client class for interacting with CodeMie API."""
+
+    def __init__(
+        self,
+        auth_server_url: str,
+        auth_realm_name: str,
+        codemie_api_domain: str,
+        auth_client_id: Optional[str] = None,
+        auth_client_secret: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        verify_ssl: bool = True,
+    ):
+        """Initialize CodeMie client with authentication credentials.
+
+        Args:
+            auth_server_url: Keycloak server URL
+            auth_realm_name: Realm name for authentication
+            codemie_api_domain: CodeMie API domain
+            auth_client_id: Client ID for authentication (optional if using username/password)
+            auth_client_secret: Client secret for authentication (optional if using username/password)
+            username: Username/email for password grant (optional if using client credentials)
+            password: Password for password grant (optional if using client credentials)
+            verify_ssl: Whether to verify SSL certificates (default: True)
+        """
+        self.auth = KeycloakCredentials(
+            server_url=auth_server_url,
+            realm_name=auth_realm_name,
+            client_id=auth_client_id,
+            client_secret=auth_client_secret,
+            username=username,
+            password=password,
+            verify_ssl=verify_ssl,
+        )
+
+        self._token: Optional[str] = None
+        self._api_domain = codemie_api_domain.rstrip("/")
+        self._verify_ssl = verify_ssl
+
+        # Initialize token first
+        self._token = self.auth.get_token()
+
+        # Initialize services with verify_ssl parameter and token
+        self.assistants = AssistantService(
+            self._api_domain, self._token, verify_ssl=verify_ssl
+        )
+        self.llms = LLMService(self._api_domain, self._token, verify_ssl=verify_ssl)
+        self.integrations = IntegrationService(
+            self._api_domain, self._token, verify_ssl=verify_ssl
+        )
+        self.tasks = TaskService(self._api_domain, self._token, verify_ssl=verify_ssl)
+        self.users = UserService(self._api_domain, self._token, verify_ssl=verify_ssl)
+        self.datasources = DatasourceService(
+            self._api_domain, self._token, verify_ssl=verify_ssl
+        )
+        self.workflows = WorkflowService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
+
+    @property
+    def token(self) -> str:
+        """Get current token or fetch new one if not available."""
+        if not self._token:
+            self._token = self.auth.get_token()
+        return self._token
+
+    def refresh_token(self) -> str:
+        """Force token refresh."""
+        self._token = self.auth.get_token()
+        # Update token in services
+        self.assistants = AssistantService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
+        self.llms = LLMService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
+        self.integrations = IntegrationService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
+        self.tasks = TaskService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
+        self.users = UserService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
+        self.datasources = DatasourceService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
+        self.workflows = WorkflowService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
+        return self._token

codemie_sdk_python-0.1.1/src/codemie_sdk/exceptions.py

@@ -0,0 +1,45 @@
+"""Custom exceptions for the CodeMie SDK."""
+
+from typing import Optional
+
+
+class CodeMieError(Exception):
+    """Base exception for all CodeMie SDK errors."""
+
+    pass
+
+
+class ApiError(CodeMieError):
+    """Exception raised for API errors."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response: Optional[dict] = None,
+    ):
+        """Initialize API error.
+
+        Args:
+            message: Error message
+            status_code: HTTP status code if applicable
+            response: Raw API response if available
+        """
+        self.status_code = status_code
+        self.response = response
+        super().__init__(message)
+
+
+class NotFoundError(ApiError):
+    """Exception raised when a resource is not found."""
+
+    def __init__(self, resource_type: str, resource_id: str):
+        """Initialize not found error.
+
+        Args:
+            resource_type: Type of resource that was not found (e.g., "Integration")
+            resource_id: ID or identifier of the resource
+        """
+        super().__init__(
+            message=f"{resource_type} with {resource_id} not found", status_code=404
+        )