codemie-sdk-python 0.1.349__tar.gz → 0.1.350__tar.gz

{codemie_sdk_python-0.1.349 → codemie_sdk_python-0.1.350}/PKG-INFO

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

{codemie_sdk_python-0.1.349 → codemie_sdk_python-0.1.350}/pyproject.toml

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

{codemie_sdk_python-0.1.349 → codemie_sdk_python-0.1.350}/src/codemie_sdk/__init__.py

@@ -116,6 +116,17 @@ from .models.categories import (
     CategoryListMetadata,
 )
 from .services.categories import CategoryService
+from .models.skill import (
+    SkillVisibility,
+    SkillCategory,
+    SkillCreateRequest,
+    SkillUpdateRequest,
+    SkillImportRequest,
+    SkillDetailResponse,
+    SkillListResponse,
+    SkillListPaginatedResponse,
+)
+from .services.skill import SkillService
 
 __version__ = "0.2.12"
 __all__ = [
@@ -202,4 +213,13 @@ __all__ = [
     "CategoryListResponse",
     "CategoryListMetadata",
     "CategoryService",
+    "SkillVisibility",
+    "SkillCategory",
+    "SkillCreateRequest",
+    "SkillUpdateRequest",
+    "SkillImportRequest",
+    "SkillDetailResponse",
+    "SkillListResponse",
+    "SkillListPaginatedResponse",
+    "SkillService",
 ]

{codemie_sdk_python-0.1.349 → codemie_sdk_python-0.1.350}/src/codemie_sdk/client/client.py

@@ -12,6 +12,7 @@ from ..services.datasource import DatasourceService
 from ..services.llm import LLMService
 from ..services.integration import IntegrationService
 from ..services.mermaid import MermaidService
+from ..services.skill import SkillService
 from ..services.task import TaskService
 from ..services.user import UserService
 from ..services.workflow import WorkflowService
@@ -91,6 +92,7 @@ class CodeMieClient:
         self.integrations = IntegrationService(
             self._api_domain, self._token, verify_ssl=verify_ssl
         )
+        self.skills = SkillService(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(
@@ -167,6 +169,9 @@ class CodeMieClient:
         self.integrations = IntegrationService(
             self._api_domain, self._token, verify_ssl=self._verify_ssl
         )
+        self.skills = SkillService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
         self.tasks = TaskService(
             self._api_domain, self._token, verify_ssl=self._verify_ssl
         )

codemie_sdk_python-0.1.350/src/codemie_sdk/models/skill.py

@@ -0,0 +1,125 @@
+"""Models for skill-related data structures."""
+
+from datetime import datetime
+from enum import Enum
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .common import User
+
+
+class SkillVisibility(str, Enum):
+    """Skill visibility options."""
+
+    PROJECT = "project"
+    PRIVATE = "private"
+    PUBLIC = "public"
+
+
+class SkillCategory(BaseModel):
+    """Skill category model."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    value: str  # Category value (e.g., "development", "testing")
+    label: str  # Human-readable label (e.g., "Development", "Testing")
+    description: Optional[str] = None
+
+
+class SkillBase(BaseModel):
+    """Base skill model."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str
+    name: str
+    description: str
+    project: str
+    visibility: SkillVisibility
+    categories: List[str] = Field(default_factory=list)
+    created_date: datetime = Field(alias="createdDate")
+
+
+class SkillListResponse(SkillBase):
+    """Skill list item response."""
+
+    created_by: Optional[User] = Field(None, alias="created_by")
+    updated_date: Optional[datetime] = Field(None, alias="updatedDate")
+    is_attached: Optional[bool] = Field(None, alias="is_attached")
+    reactions_count: Optional[int] = Field(None, alias="reactionsCount")
+    assistants_count: Optional[int] = Field(None, alias="assistantsCount")
+
+
+class SkillDetailResponse(SkillListResponse):
+    """Full skill details response."""
+
+    content: str
+    slug: Optional[str] = None
+    icon_url: Optional[str] = Field(None, alias="iconUrl")
+
+
+class SkillCreateRequest(BaseModel):
+    """Request to create a skill."""
+
+    name: str
+    description: str
+    content: str
+    project: str
+    visibility: Optional[SkillVisibility] = SkillVisibility.PROJECT
+    categories: Optional[List[str]] = Field(default_factory=list)
+
+
+class SkillUpdateRequest(BaseModel):
+    """Request to update a skill."""
+
+    name: Optional[str] = None
+    description: Optional[str] = None
+    content: Optional[str] = None
+    project: Optional[str] = None
+    visibility: Optional[SkillVisibility] = None
+    categories: Optional[List[str]] = None
+
+
+class SkillImportRequest(BaseModel):
+    """Request to import a skill from .md file."""
+
+    file_content: str
+    filename: str
+    project: str
+    visibility: Optional[SkillVisibility] = SkillVisibility.PROJECT
+
+
+class SkillAttachRequest(BaseModel):
+    """Request to attach skill to assistant."""
+
+    skill_id: str
+
+
+class SkillBulkAttachRequest(BaseModel):
+    """Request to bulk attach skill to assistants."""
+
+    assistant_ids: List[str]
+
+
+class SkillListPaginatedResponse(BaseModel):
+    """Paginated list of skills."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    skills: List[SkillListResponse]
+    page: int
+    per_page: int = Field(alias="perPage")
+    total: int
+    pages: int
+
+
+class SkillReactionResponse(BaseModel):
+    """Skill reaction response."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    resource_id: str = Field(alias="resourceId")
+    reaction: str
+    reaction_at: str = Field(alias="reactionAt")
+    resource_type: Optional[str] = Field(None, alias="resourceType")

codemie_sdk_python-0.1.350/src/codemie_sdk/services/skill.py

@@ -0,0 +1,302 @@
+"""Skill service implementation."""
+
+import json
+from typing import Any, Dict, List, Optional
+
+from ..models.skill import (
+    SkillAttachRequest,
+    SkillBulkAttachRequest,
+    SkillCategory,
+    SkillCreateRequest,
+    SkillDetailResponse,
+    SkillImportRequest,
+    SkillListPaginatedResponse,
+    SkillListResponse,
+    SkillUpdateRequest,
+)
+from ..utils.http import ApiRequestHandler
+
+
+class SkillService:
+    """Service for managing CodeMie skills."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the skill 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)
+
+    # Core CRUD Operations
+
+    def list(
+        self,
+        page: int = 0,
+        per_page: int = 12,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> SkillListPaginatedResponse:
+        """List skills with pagination.
+
+        Args:
+            page: Page number (0-based)
+            per_page: Number of items per page
+            filters: Optional filters for skills
+
+        Returns:
+            Paginated list of skills
+        """
+        params = {
+            "page": page,
+            "perPage": per_page,
+        }
+        if filters:
+            params["filters"] = json.dumps(filters)
+        return self._api.get("/v1/skills", SkillListPaginatedResponse, params=params)
+
+    def get(self, skill_id: str) -> SkillDetailResponse:
+        """Get skill by ID.
+
+        Args:
+            skill_id: Skill identifier
+
+        Returns:
+            Full skill details
+        """
+        return self._api.get(f"/v1/skills/{skill_id}", SkillDetailResponse)
+
+    def create(self, request: SkillCreateRequest) -> SkillDetailResponse:
+        """Create a new skill.
+
+        Args:
+            request: Skill creation request
+
+        Returns:
+            Created skill details
+        """
+        return self._api.post(
+            "/v1/skills",
+            SkillDetailResponse,
+            json_data=request.model_dump(exclude_none=True),
+        )
+
+    def update(self, skill_id: str, request: SkillUpdateRequest) -> SkillDetailResponse:
+        """Update an existing skill.
+
+        Args:
+            skill_id: Skill identifier
+            request: Skill update request
+
+        Returns:
+            Updated skill details
+        """
+        return self._api.put(
+            f"/v1/skills/{skill_id}",
+            SkillDetailResponse,
+            json_data=request.model_dump(exclude_none=True),
+        )
+
+    def delete(self, skill_id: str) -> dict:
+        """Delete a skill.
+
+        Args:
+            skill_id: Skill identifier
+
+        Returns:
+            Deletion confirmation
+        """
+        return self._api.delete(f"/v1/skills/{skill_id}", dict)
+
+    # Import/Export Operations
+
+    def import_skill(self, request: SkillImportRequest) -> SkillDetailResponse:
+        """Import skill from .md file content.
+
+        Args:
+            request: Skill import request with file content
+
+        Returns:
+            Imported skill details
+        """
+        return self._api.post(
+            "/v1/skills/import",
+            SkillDetailResponse,
+            json_data=request.model_dump(exclude_none=True),
+        )
+
+    def export(self, skill_id: str) -> str:
+        """Export skill.
+
+        Args:
+            skill_id: Skill identifier
+
+        Returns:
+            Exported skill markdown content
+        """
+        # Export returns raw markdown content, not JSON
+        response = self._api.get(
+            f"/v1/skills/{skill_id}/export", None, wrap_response=False
+        )
+        return response.text
+
+    # Assistant Integration
+
+    def attach_to_assistant(self, assistant_id: str, skill_id: str) -> dict:
+        """Attach skill to an assistant.
+
+        Args:
+            assistant_id: Assistant identifier
+            skill_id: Skill identifier
+
+        Returns:
+            Attachment confirmation
+        """
+        request = SkillAttachRequest(skill_id=skill_id)
+        return self._api.post(
+            f"/v1/assistants/{assistant_id}/skills",
+            dict,
+            json_data=request.model_dump(),
+        )
+
+    def detach_from_assistant(self, assistant_id: str, skill_id: str) -> dict:
+        """Detach skill from an assistant.
+
+        Args:
+            assistant_id: Assistant identifier
+            skill_id: Skill identifier
+
+        Returns:
+            Detachment confirmation
+        """
+        return self._api.delete(
+            f"/v1/assistants/{assistant_id}/skills/{skill_id}", dict
+        )
+
+    def get_assistant_skills(self, assistant_id: str) -> List[SkillListResponse]:
+        """Get all skills attached to an assistant.
+
+        Args:
+            assistant_id: Assistant identifier
+
+        Returns:
+            List of skills attached to the assistant
+        """
+        return self._api.get(
+            f"/v1/assistants/{assistant_id}/skills",
+            List[SkillListResponse],
+        )
+
+    def bulk_attach_to_assistants(
+        self, skill_id: str, assistant_ids: List[str]
+    ) -> dict:
+        """Bulk attach skill to multiple assistants.
+
+        Args:
+            skill_id: Skill identifier
+            assistant_ids: List of assistant identifiers
+
+        Returns:
+            Bulk attachment confirmation
+        """
+        request = SkillBulkAttachRequest(assistant_ids=assistant_ids)
+        return self._api.post(
+            f"/v1/skills/{skill_id}/assistants/bulk-attach",
+            dict,
+            json_data=request.model_dump(),
+        )
+
+    def get_skill_assistants(self, skill_id: str) -> List[dict]:
+        """Get all assistants using this skill.
+
+        Args:
+            skill_id: Skill identifier
+
+        Returns:
+            List of assistants using the skill
+        """
+        return self._api.get(f"/v1/skills/{skill_id}/assistants", List[dict])
+
+    # Marketplace Operations
+
+    def publish(
+        self,
+        skill_id: str,
+        categories: Optional[List[str]] = None,
+    ) -> dict:
+        """Publish skill to marketplace.
+
+        Args:
+            skill_id: Skill identifier
+            categories: Optional list of category IDs
+
+        Returns:
+            Publication confirmation
+        """
+        body = {}
+        if categories:
+            body["categories"] = categories
+        return self._api.post(
+            f"/v1/skills/{skill_id}/marketplace/publish",
+            dict,
+            json_data=body if body else None,
+        )
+
+    def unpublish(self, skill_id: str) -> dict:
+        """Unpublish skill from marketplace.
+
+        Args:
+            skill_id: Skill identifier
+
+        Returns:
+            Unpublication confirmation
+        """
+        return self._api.post(f"/v1/skills/{skill_id}/marketplace/unpublish", dict)
+
+    # Utility Methods
+
+    def list_categories(self) -> List[SkillCategory]:
+        """Get list of available skill categories.
+
+        Returns:
+            List of skill categories
+        """
+        return self._api.get("/v1/skills/categories", List[SkillCategory])
+
+    def get_users(self) -> List[dict]:
+        """Get skill users.
+
+        Returns:
+            List of users with access to skills
+        """
+        return self._api.get("/v1/skills/users", List[dict])
+
+    # Reactions
+
+    def react(self, skill_id: str, reaction: str) -> dict:
+        """React to a skill.
+
+        Args:
+            skill_id: Skill identifier
+            reaction: Reaction type (e.g., "like", "dislike")
+
+        Returns:
+            Reaction confirmation
+        """
+        return self._api.post(
+            f"/v1/skills/{skill_id}/reactions",
+            dict,
+            json_data={"reaction": reaction},
+        )
+
+    def remove_reactions(self, skill_id: str) -> dict:
+        """Remove reactions from a skill.
+
+        Args:
+            skill_id: Skill identifier
+
+        Returns:
+            Removal confirmation
+        """
+        return self._api.delete(f"/v1/skills/{skill_id}/reactions", dict)

{codemie_sdk_python-0.1.349 → codemie_sdk_python-0.1.350}/src/codemie_sdk/utils/http.py

@@ -90,6 +90,13 @@ class ApiRequestHandler:
             Parsed response object or list of objects
         """
         try:
+            # Handle empty responses (e.g., 204 No Content for DELETE operations)
+            if not response.content or response.status_code == 204:
+                logger.debug(f"Empty response with status {response.status_code}")
+                if response_model is dict:
+                    return {}
+                return None
+
             response_data = response.json()
             logger.debug(f"Received response with status {response.status_code}")
             logger.debug(f"Response datasource_type: {type(response_data)}")
@@ -109,6 +116,11 @@ class ApiRequestHandler:
                 model_class = get_args(response_model)[0]
                 if not isinstance(response_data, list):
                     response_data = [response_data]
+
+                # If List[dict], return raw data without validation
+                if model_class is dict:
+                    return response_data
+
                 return [model_class.model_validate(item) for item in response_data]
             else:
                 # Handle single model