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

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/auth/__init__.py

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

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/client/__init__.py

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

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/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
+        )

codemie_sdk/models/assistant.py

@@ -0,0 +1,192 @@
+"""Models for assistant-related data structures."""
+
+import uuid
+from datetime import datetime
+from enum import Enum
+from typing import List, Optional, Any, Union
+
+from pydantic import BaseModel, Field, ConfigDict
+
+from .common import User
+from .integration import Integration
+
+
+class ToolDetails(BaseModel):
+    """Model for tool details."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    name: str
+    label: Optional[str] = None
+    settings_config: bool = False
+    user_description: Optional[str] = None
+    settings: Optional[Integration] = None
+
+
+class ToolKitDetails(BaseModel):
+    """Model for toolkit details."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    toolkit: str
+    tools: List[ToolDetails]
+    label: str = ""
+    settings_config: bool = False
+    is_external: bool = False
+    settings: Optional[Integration] = None
+
+
+class ContextType(str, Enum):
+    """Enum for context types."""
+
+    KNOWLEDGE_BASE = "knowledge_base"
+    CODE = "code"
+
+
+class Context(BaseModel):
+    """Model for context configuration."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    context_type: ContextType
+    name: str
+
+
+class SystemPromptHistory(BaseModel):
+    """Model for system prompt history."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    system_prompt: str
+    date: datetime
+    created_by: Optional[User] = None
+
+
+class AssistantBase(BaseModel):
+    """Base model for assistant with common fields."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: Optional[str] = None
+    created_by: Optional[User] = None
+    name: str
+    description: str
+    icon_url: Optional[str] = None
+
+
+class Assistant(AssistantBase):
+    """Full assistant model with additional fields."""
+
+    model_config = ConfigDict(extra="ignore", use_enum_values=True)
+
+    system_prompt: str
+    system_prompt_history: List[SystemPromptHistory] = Field(default_factory=list)
+    project: str
+    llm_model_type: Optional[str] = None
+    toolkits: List[ToolKitDetails] = Field(default_factory=list)
+    user_prompts: List[str] = Field(default_factory=list)
+    shared: bool = False
+    is_react: bool = False
+    is_global: bool = False
+    created_date: Optional[datetime] = None
+    updated_date: Optional[datetime] = None
+    creator: str = "system"
+    slug: Optional[str] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    context: List[Context] = Field(default_factory=list)
+    user_abilities: Optional[List[Any]] = None
+
+
+class AssistantRequestBase(AssistantBase):
+    """Base model for assistant requests with common request fields."""
+
+    model_config = ConfigDict(extra="ignore", use_enum_values=True)
+
+    system_prompt: str
+    project: str
+    context: List[Context] = Field(default_factory=list)
+    llm_model_type: str
+    toolkits: List[ToolKitDetails]
+    user_prompts: List[str] = Field(default_factory=list)
+    shared: bool = False
+    is_react: bool = False
+    is_global: Optional[bool] = False
+    slug: Optional[str] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+
+
+class AssistantCreateRequest(AssistantRequestBase):
+    """Model for creating a new assistant."""
+
+    pass
+
+
+class AssistantUpdateRequest(AssistantRequestBase):
+    """Model for updating an existing assistant."""
+
+    pass
+
+
+class ChatRole(str, Enum):
+    """Enum for chat message roles."""
+
+    ASSISTANT = "Assistant"
+    USER = "User"
+
+
+class ChatMessage(BaseModel):
+    """Model for chat message."""
+
+    role: ChatRole
+    message: Optional[str] = Field(default="")
+
+
+class AssistantChatRequest(BaseModel):
+    """Model for chat request to assistant."""
+
+    conversation_id: Optional[str] = Field(
+        default=str(uuid.uuid4()), description="Conversation identifier"
+    )
+    text: Optional[str] = Field(default=None, description="User's input error_message")
+    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(
+        default=None, description="Specific LLM model to use"
+    )
+    history: Union[List[ChatMessage], str] = Field(
+        default_factory=list,
+        description="Conversation history as list of messages or string",
+    )
+    history_index: int = Field(
+        default=0, description="DataSource in conversation history"
+    )
+    stream: bool = Field(default=False, description="Enable streaming response")
+    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")
+
+
+class BaseModelResponse(BaseModel):
+    """Model for chat response from assistant."""
+
+    generated: str = Field(description="Generated response error_message")
+    time_elapsed: Optional[float] = Field(
+        default=None, alias="timeElapsed", description="Time taken for generation"
+    )
+    tokens_used: Optional[int] = Field(
+        default=None, alias="tokensUsed", description="Number of tokens used"
+    )
+    thoughts: Optional[List[dict]] = Field(
+        default=None, description="Thought process details"
+    )
+    task_id: Optional[str] = Field(
+        default=None, alias="taskId", description="Background task identifier"
+    )
+
+    class Config:
+        # Allow population by field name as well as alias
+        populate_by_name = True
+        # Preserve alias on export
+        alias_generator = None

codemie_sdk/models/common.py

@@ -0,0 +1,39 @@
+from typing import Optional, Dict, Any
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class TokensUsage(BaseModel):
+    input_tokens: Optional[int] = None
+    output_tokens: Optional[int] = None
+    money_spent: Optional[float] = None
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class User(BaseModel):
+    """Model representing the User."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    user_id: str = Field(None)
+    username: str = ""
+    name: str = ""
+
+    @model_validator(mode="before")
+    def before_init(cls, values):
+        # Check if 'id' is present, then set 'id' field for correct deserialization
+        if "id" in values:
+            values["user_id"] = values.pop("id")
+        return values
+
+
+class PaginationParams(BaseModel):
+    """Pagination parameters with validation."""
+
+    page: int = Field(..., ge=0, description="Page number (0-based)")
+    per_page: int = Field(..., gt=0, description="Number of items per page")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert pagination parameters to dictionary."""
+        return self.model_dump(exclude_none=True)