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

codemie_sdk/services/assistant.py

@@ -0,0 +1,173 @@
+"""Assistant service implementation."""
+
+import json
+from typing import List, Union, Optional, Dict, Any, Literal
+
+import requests
+
+from ..models.assistant import (
+    Assistant,
+    AssistantCreateRequest,
+    AssistantUpdateRequest,
+    ToolKitDetails,
+    AssistantChatRequest,
+    BaseModelResponse,
+    AssistantBase,
+)
+from ..models.common import PaginationParams
+from ..utils import ApiRequestHandler
+
+
+class AssistantService:
+    """Service for managing CodeMie assistants."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the assistant 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 list(
+        self,
+        minimal_response: bool = True,
+        scope: Literal["visible_to_user", "created_by_user"] = "visible_to_user",
+        page: int = 0,
+        per_page: int = 12,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> List[Union[Assistant, AssistantBase]]:
+        """Get list of available assistants.
+
+        Args:
+            minimal_response: Whether to return minimal assistant info
+            scope: Visibility scope of assistants to retrieve
+            page: Page number for pagination
+            per_page: Number of items per page
+            filters: Optional filters to apply
+
+        Returns:
+            List of assistants matching the criteria
+        """
+        params = PaginationParams(page=page, per_page=per_page).to_dict()
+        params["scope"] = scope
+        params["minimal_response"] = minimal_response
+        if filters:
+            params["filters"] = json.dumps(filters)
+
+        model = AssistantBase if minimal_response else Assistant
+        return self._api.get("/v1/assistants", List[model], params=params)
+
+    def get(self, assistant_id: str) -> Assistant:
+        """Get assistant by ID.
+
+        Args:
+            assistant_id: ID of the assistant to retrieve
+
+        Returns:
+            Assistant details
+        """
+        return self._api.get(f"/v1/assistants/id/{assistant_id}", Assistant)
+
+    def get_by_slug(self, slug: str) -> Assistant:
+        """Get assistant by slug.
+
+        Args:
+            slug: Slug of the assistant to retrieve
+
+        Returns:
+            Assistant details
+        """
+        return self._api.get(f"/v1/assistants/slug/{slug}", Assistant)
+
+    def create(self, request: AssistantCreateRequest) -> dict:
+        """Create a new assistant.
+
+        Args:
+            request: Assistant creation request
+
+        Returns:
+            Created assistant details
+        """
+        return self._api.post(
+            "/v1/assistants", dict, json_data=request.model_dump(exclude_none=True)
+        )
+
+    def update(self, assistant_id: str, request: AssistantUpdateRequest) -> dict:
+        """Update an existing assistant.
+
+        Args:
+            assistant_id: ID of the assistant to update
+            request: Assistant update request
+
+        Returns:
+            Updated assistant details
+        """
+        return self._api.put(
+            f"/v1/assistants/{assistant_id}",
+            dict,
+            json_data=request.model_dump(exclude_none=True),
+        )
+
+    def get_tools(self) -> List[ToolKitDetails]:
+        """Get list of available tools.
+
+        Returns:
+            List of available tool kits
+        """
+        return self._api.get(
+            "/v1/assistants/tools", List[ToolKitDetails], wrap_response=False
+        )
+
+    def delete(self, assistant_id: str) -> dict:
+        """Delete an assistant by ID.
+
+        Args:
+            assistant_id: ID of the assistant to delete
+
+        Returns:
+            Deletion confirmation
+        """
+        return self._api.delete(f"/v1/assistants/{assistant_id}", dict)
+
+    def get_prebuilt(self) -> List[Assistant]:
+        """Get list of prebuilt assistants.
+
+        Returns:
+            List of prebuilt assistants
+        """
+        return self._api.get("/v1/assistants/prebuilt", List[Assistant])
+
+    def get_prebuilt_by_slug(self, slug: str) -> Assistant:
+        """Get prebuilt assistant by slug.
+
+        Args:
+            slug: Slug of the prebuilt assistant to retrieve
+
+        Returns:
+            Prebuilt assistant details
+        """
+        return self._api.get(f"/v1/assistants/prebuilt/{slug}", Assistant)
+
+    def chat(
+        self,
+        assistant_id: str,
+        request: AssistantChatRequest,
+    ) -> Union[requests.Response, BaseModelResponse]:
+        """Send a chat request to an assistant.
+
+        Args:
+            assistant_id: ID of the assistant to chat with
+            request: Chat request details
+
+        Returns:
+            Chat response or streaming response
+        """
+        return self._api.post(
+            f"/v1/assistants/{assistant_id}/model",
+            BaseModelResponse,
+            json_data=request.model_dump(exclude_none=True, by_alias=True),
+            stream=request.stream,
+        )

codemie_sdk/services/datasource.py

@@ -0,0 +1,150 @@
+"""DataSource service implementation."""
+
+import json
+from typing import Literal, List
+
+from ..models.common import PaginationParams
+from ..models.datasource import (
+    DataSource,
+    DataSourceType,
+    DataSourceStatus,
+    BaseDataSourceRequest,
+    CodeDataSourceRequest,
+    UpdateCodeDataSourceRequest,
+    BaseUpdateDataSourceRequest,
+)
+from ..utils import ApiRequestHandler
+
+
+class DatasourceService:
+    """Service for managing CodeMie Datasources."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the datasource 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 create(self, request: BaseDataSourceRequest) -> dict:
+        """Create a new datasource.
+
+        Args:
+            request: Create datasource request
+
+        Returns:
+            dict: Response from the server containing operation status
+        """
+        if isinstance(request, CodeDataSourceRequest):
+            endpoint = f"/v1/application/{request.project_name}/index"
+        else:
+            # All other datasources follow the same pattern
+            endpoint = f"/v1/index/knowledge_base/{request.type.name.lower()}"
+
+        return self._api.post(
+            endpoint,
+            dict,
+            json_data=request.model_dump(by_alias=True, exclude_none=True),
+        )
+
+    def update(self, datasource_id: str, request: BaseUpdateDataSourceRequest) -> dict:
+        """Update an existing datasource.
+
+        Args:
+            request: Update datasource request
+
+        Returns:
+            dict: Response from the server containing operation status
+        """
+        if isinstance(request, UpdateCodeDataSourceRequest):
+            endpoint = f"/v1/application/{request.project_name}/index/{request.name}"
+        else:
+            endpoint = f"/v1/index/knowledge_base/{request.type.name.lower()}"
+
+        # Extract reindex params
+        params = {
+            "full_reindex": request.full_reindex,
+            "skip_reindex": request.skip_reindex,
+            "resume_indexing": request.resume_indexing,
+            "incremental_reindex": request.incremental_reindex,
+        }
+
+        # Remove reindex fields from request body
+        data = request.model_dump(by_alias=True, exclude_none=True)
+        for param in params.keys():
+            data.pop(param, None)
+
+        return self._api.put(endpoint, dict, params=params, json_data=data)
+
+    def list(
+        self,
+        page: int = 0,
+        per_page: int = 10,
+        sort_key: Literal["date", "update_date"] = "update_date",
+        sort_order: Literal["asc", "desc"] = "desc",
+        datasource_types: List[DataSourceType] = None,
+        projects: List[str] = None,
+        owner: str = None,
+        status: DataSourceStatus = None,
+    ) -> List[DataSource]:
+        """
+        List datasources with pagination and sorting support.
+
+        Args:
+            page: Page number (0-based). Defaults to 0.
+            per_page: Number of items per page. Defaults to 10.
+            sort_key: Field to sort by. Either "date" or "update_date". Defaults to "update_date".
+            sort_order: Sort order. Either "asc" or "desc". Defaults to "desc".
+            datasource_types: Optional data source types to filter by.
+            projects: Optional projects to filter by.
+            owner: Optional owner to filter by in format: FirstName LastName.
+            status: Optional data source status to filter by.
+
+        Returns:
+            DataSourceListResponse object containing list of datasources and pagination information.
+        """
+        params = PaginationParams(page=page, per_page=per_page).to_dict()
+        params["sort_key"] = sort_key
+        params["sort_order"] = sort_order
+
+        filters = {}
+        if datasource_types:
+            filters["index_type"] = datasource_types
+        if projects:
+            filters["project"] = projects
+        if status:
+            filters["status"] = status.value
+        if owner:
+            filters["created_by"] = owner
+        if filters:
+            params["filters"] = json.dumps(filters)
+        return self._api.get("/v1/index", List[DataSource], params=params)
+
+    def get(self, datasource_id: str) -> DataSource:
+        """
+        Get datasource by ID.
+
+        Args:
+            datasource_id: The ID of the datasource to retrieve.
+
+        Returns:
+            DataSource object containing the datasource information.
+
+        Raises:
+            ApiError: If the datasource is not found or other API errors occur.
+        """
+        return self._api.get(f"/v1/index/{datasource_id}", DataSource)
+
+    def delete(self, datasource_id: str) -> dict:
+        """Delete an datasource by ID.
+
+        Args:
+            datasource_id: ID of the datasource to delete
+
+        Returns:
+            Deletion confirmation
+        """
+        return self._api.delete(f"/v1/index/{datasource_id}", dict)

codemie_sdk/services/integration.py

@@ -0,0 +1,152 @@
+"""Integration service implementation."""
+
+import json
+from typing import List, Optional, Dict, Any
+
+from ..exceptions import NotFoundError
+from ..models.common import PaginationParams
+from ..models.integration import Integration, IntegrationType
+from ..utils import ApiRequestHandler
+
+
+class IntegrationService:
+    """Service for managing CodeMie integrations (both user and project settings)."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the integration 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_base_path(self, setting_type: IntegrationType) -> str:
+        """Get base API path based on setting type.
+
+        Args:
+            setting_type: Type of settings (USER or PROJECT)
+
+        Returns:
+            Base API path for the specified setting type
+        """
+        return f"/v1/settings/{'user' if setting_type == IntegrationType.USER else 'project'}"
+
+    def list(
+        self,
+        setting_type: IntegrationType = IntegrationType.USER,
+        page: int = 0,
+        per_page: int = 10,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> List[Integration]:
+        """Get list of available integrations.
+
+        Args:
+            setting_type: Type of settings to list (USER or PROJECT)
+            page: Page number for pagination
+            per_page: Number of items per page
+            filters: Optional filters to apply
+
+        Returns:
+            List of integrations matching the criteria
+        """
+        params = PaginationParams(page=page, per_page=per_page).to_dict()
+        if filters:
+            params["filters"] = json.dumps(filters)
+
+        return self._api.get(
+            self._get_base_path(setting_type), List[Integration], params=params
+        )
+
+    def get(
+        self, integration_id: str, setting_type: IntegrationType = IntegrationType.USER
+    ) -> Integration:
+        """Get integration by ID.
+
+        Args:
+            integration_id: ID of the integration to retrieve
+            setting_type: Type of settings to get (USER or PROJECT)
+
+        Returns:
+            Integration details
+
+        Raises:
+            NotFoundError: If integration with given ID is not found
+        """
+        integrations = self.list(setting_type=setting_type, per_page=100)
+        integration = next((i for i in integrations if i.id == integration_id), None)
+        if integration is None:
+            raise NotFoundError("Integration", integration_id)
+
+        return integration
+
+    def get_by_alias(
+        self, alias: str, setting_type: IntegrationType = IntegrationType.USER
+    ) -> Optional[Integration]:
+        """Get integration by its alias.
+
+        Args:
+            alias: Alias of the integration to retrieve
+            setting_type: Type of settings to get (USER or PROJECT)
+
+        Returns:
+            Integration details if found, None otherwise
+
+        Raises:
+            NotFoundError: If integration with given alias is not found
+        """
+        integrations = self.list(setting_type=setting_type, per_page=100)
+        integration = next((i for i in integrations if i.alias == alias), None)
+
+        if integration is None:
+            raise NotFoundError("Integration", alias)
+
+        return integration
+
+    def create(self, settings: Integration) -> dict:
+        """Create a new integration.
+
+        Args:
+            settings: integration creation request
+
+        Returns:
+            Created integration details
+        """
+        return self._api.post(
+            self._get_base_path(settings.setting_type),
+            dict,
+            json_data=settings.model_dump(exclude_none=True),
+        )
+
+    def update(self, setting_id: str, settings: Integration) -> dict:
+        """Update an existing integration.
+
+        Args:
+            setting_id: ID of the integration to update
+            settings: integration update request
+
+        Returns:
+            Updated integration details
+        """
+        return self._api.put(
+            f"{self._get_base_path(settings.setting_type)}/{setting_id}",
+            dict,
+            json_data=settings.model_dump(exclude_none=True),
+        )
+
+    def delete(
+        self, setting_id: str, setting_type: IntegrationType = IntegrationType.USER
+    ) -> dict:
+        """Delete an integration by ID.
+
+        Args:
+            setting_id: ID of the integration to delete
+            setting_type: Type of settings to delete (USER or PROJECT)
+
+        Returns:
+            Deletion confirmation
+        """
+        return self._api.delete(
+            f"{self._get_base_path(setting_type)}/{setting_id}", dict
+        )

codemie_sdk/services/llm.py

@@ -0,0 +1,38 @@
+"""LLM service implementation."""
+
+from typing import List
+
+from ..models.llm import LLMModel
+from ..utils.http import ApiRequestHandler
+
+
+class LLMService:
+    """Service for managing LLM models."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the LLM models service.
+
+        Args:
+            api_domain: Base URL for the CodeMie API
+            token: Authentication token
+            verify_ssl: Whether to verify SSL certificates. Default: True
+        """
+        self._api = ApiRequestHandler(api_domain, token, verify_ssl)
+
+    def list(self) -> List[LLMModel]:
+        """Get list of available LLM models.
+
+        Returns:
+            List of LLM models
+        """
+        return self._api.get("/v1/llm_models", List[LLMModel], wrap_response=False)
+
+    def list_embeddings(self) -> List[LLMModel]:
+        """Get list of available embeddings models.
+
+        Returns:
+            List of embeddings models
+        """
+        return self._api.get(
+            "/v1/embeddings_models", List[LLMModel], wrap_response=False
+        )

codemie_sdk/services/task.py

@@ -0,0 +1,34 @@
+"""Task service implementation."""
+
+from ..models.task import BackgroundTaskEntity
+from ..utils.http import ApiRequestHandler
+
+
+class TaskService:
+    """Service for managing background tasks."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the Task service.
+
+        Args:
+            api_domain: Base URL for the CodeMie API
+            token: Authentication token
+            verify_ssl: Whether to verify SSL certificates. Default: True
+        """
+        self._api = ApiRequestHandler(api_domain, token, verify_ssl)
+
+    def get(self, task_id: str) -> BackgroundTaskEntity:
+        """Get a background task by ID.
+
+        Args:
+            task_id: The ID of the task to retrieve
+
+        Returns:
+            BackgroundTaskEntity: The task details
+
+        Raises:
+            ApiError: If the task doesn't exist or there's an API error
+        """
+        return self._api.get(
+            f"/v1/tasks/{task_id}", BackgroundTaskEntity, wrap_response=False
+        )

codemie_sdk/services/user.py

@@ -0,0 +1,34 @@
+"""User service implementation."""
+
+from ..models.user import User, UserData
+from ..utils.http import ApiRequestHandler
+
+
+class UserService:
+    """Service for managing user profile and preferences."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the User service.
+
+        Args:
+            api_domain: Base URL for the CodeMie API
+            token: Authentication token
+            verify_ssl: Whether to verify SSL certificates. Default: True
+        """
+        self._api = ApiRequestHandler(api_domain, token, verify_ssl)
+
+    def about_me(self) -> User:
+        """Get current user profile.
+
+        Returns:
+            User profile information
+        """
+        return self._api.get("/v1/user", User, wrap_response=False)
+
+    def get_data(self) -> UserData:
+        """Get user data and preferences.
+
+        Returns:
+            User data and preferences
+        """
+        return self._api.get("/v1/user/data", UserData, wrap_response=False)