codemie-sdk-python 0.1.520__tar.gz → 0.1.522__tar.gz

{codemie_sdk_python-0.1.520 → codemie_sdk_python-0.1.522}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codemie-sdk-python
-Version: 0.1.520
+Version: 0.1.522
 Summary: CodeMie SDK for Python
 Author: Vadym Vlasenko
 Author-email: vadym_vlasenko@epam.com

{codemie_sdk_python-0.1.520 → codemie_sdk_python-0.1.522}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "codemie-sdk-python"
-version = "0.1.520"
+version = "0.1.522"
 description = "CodeMie SDK for Python"
 authors = [
     "Vadym Vlasenko <vadym_vlasenko@epam.com>",

{codemie_sdk_python-0.1.520 → codemie_sdk_python-0.1.522}/src/codemie_sdk/__init__.py

@@ -152,12 +152,17 @@ from .models.assistant import (
     BuiltinSubagent,
     AssistantProjectFeature,
     AssistantProjectMappingRequest,
-    AssistantProjectMappingResponse,
+    AssistantProjectMappingPagination,
+    AssistantProjectMappingListResponse,
 )
 
 __version__ = "0.2.12"
 __all__ = [
     "CodeMieClient",
+    "AssistantProjectFeature",
+    "AssistantProjectMappingRequest",
+    "AssistantProjectMappingPagination",
+    "AssistantProjectMappingListResponse",
     "VendorType",
     "VendorAssistantSetting",
     "VendorAssistantSettingsResponse",
@@ -269,7 +274,4 @@ __all__ = [
     "SkillPagination",
     "SkillService",
     "BuiltinSubagent",
-    "AssistantProjectFeature",
-    "AssistantProjectMappingRequest",
-    "AssistantProjectMappingResponse",
 ]

{codemie_sdk_python-0.1.520 → codemie_sdk_python-0.1.522}/src/codemie_sdk/models/assistant.py

@@ -610,23 +610,50 @@ class ReactionRequest(BaseModel):
 
 
 class AssistantProjectFeature(str, Enum):
-    """Enum for assistant project feature discriminators."""
+    """Feature discriminator for assistant/project mappings (e.g. Teams bot).
 
-    teams = "teams"
+    This enum is expected to grow over time on the backend; treat unrecognized
+    wire values defensively rather than assuming this is the complete set.
+    """
+
+    TEAMS = "teams"
 
 
 class AssistantProjectMappingRequest(BaseModel):
-    """Request body for enabling an assistant for a project feature."""
+    """Request body for POST /v1/assistants/{assistant_id}/projects/mapping."""
 
     model_config = ConfigDict(extra="ignore", use_enum_values=True)
 
-    project_name: str = Field(description="Project identifier")
-    feature: AssistantProjectFeature = Field(description="Feature discriminator")
+    project_name: str = Field(description="Project (application) name")
+    feature: AssistantProjectFeature = Field(
+        description="Feature discriminator this mapping is for, e.g. 'teams'"
+    )
+
+
+class AssistantProjectMappingPagination(BaseModel):
+    """Pagination metadata returned by GET /v1/assistants/projects/mapping."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    page: int = Field(description="Current page, 0-indexed")
+    per_page: int = Field(description="Items per page")
+    total: int = Field(description="Total matching assistants across all pages")
 
 
-class AssistantProjectMappingResponse(BaseModel):
-    """Response for assistant project mapping operations."""
+class AssistantProjectMappingListResponse(BaseModel):
+    """Response for GET /v1/assistants/projects/mapping.
+
+    List items are intentionally typed as ``dict[str, Any]`` rather than
+    ``Assistant``/``AssistantBase``. The backend contract documents this
+    endpoint as returning "the same shape as GET /v1/assistants", but that
+    endpoint's own shape is parameterized by a ``minimal_response`` flag that
+    this new endpoint does not expose, and the exact per-item fields returned
+    here are not otherwise confirmed. Rather than guess the wire format,
+    callers get the raw dict and can assert on whichever fields they need
+    (e.g. ``item["id"]``).
+    """
 
     model_config = ConfigDict(extra="ignore")
 
-    message: str = Field(description="Operation result message")
+    data: list[dict[str, Any]] = Field(default_factory=list)
+    pagination: AssistantProjectMappingPagination

{codemie_sdk_python-0.1.520 → codemie_sdk_python-0.1.522}/src/codemie_sdk/services/assistant.py

@@ -30,9 +30,10 @@ from ..models.assistant import (
     ReactionRequest,
     AssistantProjectFeature,
     AssistantProjectMappingRequest,
-    AssistantProjectMappingResponse,
+    AssistantProjectMappingListResponse,
 )
 from ..models.common import PaginationParams
+from ..models.conversation import BaseResponse
 from ..utils import ApiRequestHandler, TokenSource
 
 
@@ -613,78 +614,92 @@ class AssistantService:
 
     def list_project_mapping(
         self,
-        feature: Union[AssistantProjectFeature, str],
-        project: str,
+        project_name: str,
+        feature: AssistantProjectFeature = AssistantProjectFeature.TEAMS,
         page: int = 0,
         per_page: int = 12,
-    ) -> list[Assistant]:
-        """List assistants enabled for a project feature.
+    ) -> AssistantProjectMappingListResponse:
+        """List assistants enabled for a project feature (e.g. Teams bot).
+
+        Accessible to any member of ``project_name``, not just project admins.
 
         Args:
-            feature: Feature discriminator (e.g. "teams")
-            project: Project name (application name)
-            page: 0-indexed page number
-            per_page: Items per page (max 100)
+            project_name: Project (application) name to list mappings for
+            feature: Feature discriminator, currently only "teams"
+            page: Page number, 0-indexed
+            per_page: Items per page (default 12, max 10000)
 
         Returns:
-            List of assistants mapped to the project feature
+            Paginated list of assistants enabled for the project feature
         """
-        params = {
-            "feature": feature if isinstance(feature, str) else feature.value,
-            "project": project,
-            "page": page,
-            "per_page": per_page,
-        }
+        feature_value = (
+            feature.value if isinstance(feature, AssistantProjectFeature) else feature
+        )
+        params = PaginationParams(page=page, per_page=per_page).to_dict()
+        params["feature"] = feature_value
+        params["project"] = project_name
         return self._api.get(
-            "/v1/assistants/projects/mapping", list[Assistant], params=params
+            "/v1/assistants/projects/mapping",
+            AssistantProjectMappingListResponse,
+            params=params,
+            wrap_response=False,
         )
 
-    def enable_project_mapping(
+    def enable_for_project(
         self,
         assistant_id: str,
-        request: AssistantProjectMappingRequest,
-    ) -> AssistantProjectMappingResponse:
-        """Enable an assistant for a project feature.
+        project_name: str,
+        feature: AssistantProjectFeature = AssistantProjectFeature.TEAMS,
+    ) -> BaseResponse:
+        """Enable an assistant for a project feature (e.g. Teams bot).
 
-        Idempotent: returns 200 whether the mapping already existed or not.
+        Idempotent — calling this when the mapping already exists returns 200
+        with no error. Requires the caller to be a project admin/maintainer
+        (or application admin) for ``project_name``.
 
         Args:
-            assistant_id: UUID of the assistant
-            request: Mapping request with project_name and feature
+            assistant_id: ID of the assistant to enable
+            project_name: Project (application) name to enable the mapping for
+            feature: Feature discriminator, currently only "teams"
 
         Returns:
-            AssistantProjectMappingResponse with confirmation message
+            Response confirming the assistant was enabled
         """
+        request = AssistantProjectMappingRequest(
+            project_name=project_name, feature=feature
+        )
         return self._api.post(
             f"/v1/assistants/{assistant_id}/projects/mapping",
-            AssistantProjectMappingResponse,
+            BaseResponse,
             json_data=request.model_dump(exclude_none=True),
-            wrap_response=False,
         )
 
-    def disable_project_mapping(
+    def disable_for_project(
         self,
         assistant_id: str,
-        project: str,
-        feature: Union[AssistantProjectFeature, str],
-    ) -> AssistantProjectMappingResponse:
-        """Disable an assistant for a project feature.
+        project_name: str,
+        feature: AssistantProjectFeature = AssistantProjectFeature.TEAMS,
+    ) -> BaseResponse:
+        """Disable an assistant for a project feature (e.g. Teams bot).
+
+        Raises an HTTP error (404) if the mapping does not exist. Requires the
+        caller to be a project admin/maintainer (or application admin) for
+        ``project_name``.
 
         Args:
-            assistant_id: UUID of the assistant
-            project: Project name
-            feature: Feature discriminator (e.g. "teams")
+            assistant_id: ID of the assistant to disable
+            project_name: Project (application) name to disable the mapping for
+            feature: Feature discriminator, currently only "teams"
 
         Returns:
-            AssistantProjectMappingResponse with confirmation message
+            Response confirming the assistant was disabled
         """
-        params = {
-            "project": project,
-            "feature": feature if isinstance(feature, str) else feature.value,
-        }
+        feature_value = (
+            feature.value if isinstance(feature, AssistantProjectFeature) else feature
+        )
+        params = {"project": project_name, "feature": feature_value}
         return self._api.delete(
             f"/v1/assistants/{assistant_id}/projects/mapping",
-            AssistantProjectMappingResponse,
+            BaseResponse,
             params=params,
-            wrap_response=False,
         )

{codemie_sdk_python-0.1.520 → codemie_sdk_python-0.1.522}/src/codemie_sdk/services/datasource.py

@@ -60,26 +60,20 @@ class DatasourceService:
             json_data=request.model_dump(by_alias=True, exclude_none=True),
         )
 
-    def create_file_datasource(
-        self,
-        request: FileDataSourceRequest,
+    @staticmethod
+    def _build_file_uploads(
         files: list[str | Tuple[str, bytes, str]],
-    ) -> dict:
-        """Create a new file datasource with file uploads.
+    ) -> list[tuple[str, tuple[str, bytes, str]]]:
+        """Build multipart file tuples from file paths or (filename, content, mime_type) tuples.
 
         Args:
-            request: File datasource creation request
             files: List of files to upload. Each item can be:
                    - str: file path (will read file and detect MIME type)
                    - Tuple[str, bytes, str]: (filename, content, mime_type)
 
         Returns:
-            dict: Response from the server containing operation status
+            list: Multipart-ready ("files", (filename, content, mime_type)) tuples
         """
-        endpoint = "/v1/index/knowledge_base/file"
-
-        # Prepare multipart form data
-        params = request.model_dump(by_alias=True, exclude_none=True)
         file_uploads = []
 
         for file_item in files:
@@ -106,15 +100,47 @@ class DatasourceService:
                     "Each file must be either a file path (str) or a tuple of (filename, content, mime_type)"
                 )
 
+        return file_uploads
+
+    def create_file_datasource(
+        self,
+        request: FileDataSourceRequest,
+        files: list[str | Tuple[str, bytes, str]],
+    ) -> dict:
+        """Create a new file datasource with file uploads.
+
+        Args:
+            request: File datasource creation request
+            files: List of files to upload. Each item can be:
+                   - str: file path (will read file and detect MIME type)
+                   - Tuple[str, bytes, str]: (filename, content, mime_type)
+
+        Returns:
+            dict: Response from the server containing operation status
+        """
+        endpoint = "/v1/index/knowledge_base/file"
+
+        # Prepare multipart form data
+        params = request.model_dump(by_alias=True, exclude_none=True)
+        file_uploads = self._build_file_uploads(files)
+
         return self._api.post_multipart(
             endpoint, dict, params=params, files=file_uploads
         )
 
-    def update(self, datasource_id: str, request: BaseUpdateDataSourceRequest) -> dict:
+    def update(
+        self,
+        datasource_id: str,
+        request: BaseUpdateDataSourceRequest,
+        files: list[str | Tuple[str, bytes, str]] | None = None,
+    ) -> dict:
         """Update an existing datasource.
 
         Args:
             request: Update datasource request
+            files: Optional list of files to add to a File datasource. Each item
+                   can be a file path (str) or a (filename, content, mime_type)
+                   tuple. Only supported for UpdateFileDataSourceRequest.
 
         Returns:
             dict: Response from the server containing operation status
@@ -140,6 +166,11 @@ class DatasourceService:
         # PUT /index/knowledge_base/file now uses Depends() — all fields are query params
         if isinstance(request, UpdateFileDataSourceRequest):
             params.update(data)
+            if files:
+                file_uploads = self._build_file_uploads(files)
+                return self._api.put_multipart(
+                    endpoint, dict, params=params, files=file_uploads
+                )
             return self._api.put(endpoint, dict, {}, params=params)
 
         return self._api.put(endpoint, dict, params=params, json_data=data)

{codemie_sdk_python-0.1.520 → codemie_sdk_python-0.1.522}/src/codemie_sdk/utils/http.py

@@ -274,6 +274,40 @@ class ApiRequestHandler:
 
         return self._parse_response(response, response_model, wrap_response)
 
+    @log_request
+    def put_multipart(
+        self,
+        endpoint: str,
+        response_model: Type[T],
+        params: dict[str, Any] | None = None,
+        files: list | None = None,
+        wrap_response: bool = True,
+    ) -> T:
+        """Makes a PUT multipart/form-data request and parses the response.
+
+        Args:
+            endpoint: API endpoint path
+            response_model: Pydantic model class or list[Model] for response
+            params: Url parameters
+            files: List of file tuples for upload
+            wrap_response: Whether response is wrapped in 'data' field
+
+        Returns:
+            Parsed response object or list of objects
+        """
+        response = requests.put(
+            url=f"{self._base_url}{endpoint}",
+            headers=self._get_headers(
+                exclude_content_type=True
+            ),  # Let requests set multipart content-type
+            params=params,
+            files=files,
+            verify=self._verify_ssl,
+        )
+        response.raise_for_status()
+
+        return self._parse_response(response, response_model, wrap_response)
+
     @log_request
     def put(
         self,