codemie-sdk-python 0.1.514__tar.gz → 0.1.516__tar.gz

{codemie_sdk_python-0.1.514 → codemie_sdk_python-0.1.516}/PKG-INFO

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

{codemie_sdk_python-0.1.514 → codemie_sdk_python-0.1.516}/pyproject.toml

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

{codemie_sdk_python-0.1.514 → codemie_sdk_python-0.1.516}/src/codemie_sdk/client/client.py

@@ -24,6 +24,7 @@ from ..services.vendor_workflow import VendorWorkflowService
 from ..services.vendor_knowledgebase import VendorKnowledgeBaseService
 from ..services.vendor_guardrail import VendorGuardrailService
 from ..services.vendor_runtime import VendorRuntimeService
+from ..services.activity_event import ActivityEventService
 from ..services.codemie_guardrails import CodemieGuardrailService
 
 
@@ -157,6 +158,9 @@ class CodeMieClient:
         self.codemie_guardrails = CodemieGuardrailService(
             self._api_domain, _token_source, verify_ssl=self._verify_ssl
         )
+        self.activity_events = ActivityEventService(
+            self._api_domain, _token_source, verify_ssl=self._verify_ssl
+        )
 
     @property
     def token(self) -> str:

codemie_sdk_python-0.1.516/src/codemie_sdk/models/activity_event.py

@@ -0,0 +1,45 @@
+"""Models for activity event data structures."""
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ActivityEventListItem(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    id: str
+    domain: str
+    event_type: str
+    entity_type: Optional[str] = None
+    entity_id: Optional[str] = None
+    actor_id: Optional[str] = None
+    actor_email: Optional[str] = None
+    actor_name: Optional[str] = None
+    attributes: Optional[Dict[str, Any]] = None
+    created_at: datetime
+
+
+class ActivityEventPagination(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    total: int
+    page: int = 0
+    per_page: int
+    pages: int = 1
+
+
+class PaginatedActivityEventResponse(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    data: List[ActivityEventListItem]
+    pagination: ActivityEventPagination
+
+
+class ActivityEventFilterOptions(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    domains: List[str]
+    event_types: List[str]
+    entity_types: List[str]

{codemie_sdk_python-0.1.514 → codemie_sdk_python-0.1.516}/src/codemie_sdk/models/workflow.py

@@ -100,3 +100,73 @@ class WorkflowEvaluationRequest(BaseModel):
     max_concurrency: int = Field(
         default=1, ge=1, le=5, description="Maximum number of concurrent evaluations"
     )
+
+
+class WorkflowGeneratorRequest(BaseModel):
+    """Request model for generating a workflow from a natural language description.
+
+    Maps to the backend's ``WorkflowGeneratorRequest``
+    (``src/codemie/rest_api/models/workflow_generator.py``), where the wire field
+    for the natural language description is ``text`` (not ``nl_query`` — that name
+    is only used internally as the service-layer parameter).
+    """
+
+    text: str = Field(..., min_length=1)
+    llm_model: str | None = None
+    persist: bool = False
+    guardrail_ids: list[str] | None = None
+
+
+class WorkflowGeneratedState(BaseModel):
+    """A single generated state (node) inside a generated workflow config."""
+
+    model_config = ConfigDict(extra="allow")
+
+    id: str | None = None
+    assistant_id: str | None = None
+    tool_id: str | None = None
+    custom_node_id: str | None = None
+    task: str | None = None
+    next: dict | None = None
+
+
+class WorkflowGeneratedAssistant(BaseModel):
+    """A single generated assistant reference inside a generated workflow config."""
+
+    model_config = ConfigDict(extra="allow")
+
+    id: str | None = None
+    assistant_id: str | None = None
+
+
+class WorkflowGeneratorConfig(BaseModel):
+    """The generated workflow configuration returned by the generator.
+
+    Mirrors the backend's ``CreateWorkflowRequest`` shape
+    (``src/codemie/core/workflow_models/workflow_models.py``). Uses
+    ``extra="allow"`` since the backend model carries additional fields (e.g.
+    ``guardrail_assignments``) that are not required for test assertions.
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    name: str
+    description: str | None = None
+    project: str | None = None
+    mode: WorkflowMode = WorkflowMode.SEQUENTIAL
+    yaml_config: str | None = None
+    shared: bool = True
+    assistants: list[WorkflowGeneratedAssistant] = Field(default_factory=list)
+    tools: list[dict] = Field(default_factory=list)
+    states: list[WorkflowGeneratedState] = Field(default_factory=list)
+    supervisor_prompt: str | None = ""
+    meta_config: str | None = None
+
+
+class WorkflowGeneratorResponse(BaseModel):
+    """Response model for ``POST /v1/workflows/generate``."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    workflow_config: WorkflowGeneratorConfig
+    workflow_id: str | None = None

codemie_sdk_python-0.1.516/src/codemie_sdk/services/activity_event.py

@@ -0,0 +1,103 @@
+"""Activity event service implementation (maintainer only)."""
+
+from typing import List, Optional
+
+from ..models.activity_event import (
+    ActivityEventFilterOptions,
+    PaginatedActivityEventResponse,
+)
+from ..utils import ApiRequestHandler, TokenSource
+
+
+class ActivityEventService:
+    """Service for querying the activity events audit log.
+
+    Requires maintainer privileges — all methods raise HTTP 403 for
+    non-maintainer callers.
+    """
+
+    def __init__(self, api_domain: str, token: TokenSource, verify_ssl: bool = True):
+        """Initialize the activity event service.
+
+        Args:
+            api_domain: Base URL for the CodeMie API
+            token: Authentication token source
+            verify_ssl: Whether to verify SSL certificates
+        """
+        self._api = ApiRequestHandler(api_domain, token, verify_ssl)
+
+    def list_events(
+        self,
+        *,
+        actor_id: Optional[str] = None,
+        domain: Optional[List[str]] = None,
+        event_type: Optional[List[str]] = None,
+        entity_type: Optional[List[str]] = None,
+        entity_id: Optional[str] = None,
+        from_dt: Optional[str] = None,
+        to_dt: Optional[str] = None,
+        sort_dir: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> PaginatedActivityEventResponse:
+        """List activity events with optional filters.
+
+        Multi-value parameters (domain, event_type, entity_type) are serialised
+        as repeated query params: e.g. ?domain=user_management&domain=budget_management.
+
+        Args:
+            actor_id: Filter by actor user ID
+            domain: Filter by domain(s)
+            event_type: Filter by event type(s)
+            entity_type: Filter by entity type(s)
+            entity_id: Filter by entity ID
+            from_dt: ISO 8601 lower bound datetime (maps to 'from' query param)
+            to_dt: ISO 8601 upper bound datetime (maps to 'to' query param)
+            sort_dir: 'asc' or 'desc' (default 'desc')
+            limit: Results per page, 1-1000 (default 50)
+            offset: Pagination offset (default 0)
+
+        Returns:
+            PaginatedActivityEventResponse
+        """
+        params: dict = {}
+        if actor_id is not None:
+            params["actor_id"] = actor_id
+        if domain is not None:
+            params["domain"] = domain
+        if event_type is not None:
+            params["event_type"] = event_type
+        if entity_type is not None:
+            params["entity_type"] = entity_type
+        if entity_id is not None:
+            params["entity_id"] = entity_id
+        if from_dt is not None:
+            params["from"] = from_dt
+        if to_dt is not None:
+            params["to"] = to_dt
+        if sort_dir is not None:
+            params["sort_dir"] = sort_dir
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
+
+        return self._api.get(
+            "/v1/admin/activity-events",
+            PaginatedActivityEventResponse,
+            params=params if params else None,
+            wrap_response=False,
+        )
+
+    def get_filter_options(self) -> ActivityEventFilterOptions:
+        """Get distinct filter options available for activity events.
+
+        Returns:
+            ActivityEventFilterOptions with distinct domains, event_types,
+            and entity_types present in the audit log.
+        """
+        return self._api.get(
+            "/v1/admin/activity-events/filter-options",
+            ActivityEventFilterOptions,
+            wrap_response=False,
+        )

{codemie_sdk_python-0.1.514 → codemie_sdk_python-0.1.516}/src/codemie_sdk/services/user.py

@@ -170,3 +170,19 @@ class UserService:
             dict,
             wrap_response=False,
         )
+
+    def reactivate_user(self, user_id: str) -> CodeMieUserDetail:
+        """Reactivate a previously deactivated user (SuperAdmin only).
+
+        Args:
+            user_id: The user's unique identifier
+
+        Returns:
+            Updated user details with is_active=True
+        """
+        return self._api.put(
+            f"/v1/admin/users/{user_id}",
+            CodeMieUserDetail,
+            json_data={"is_active": True},
+            wrap_response=False,
+        )

{codemie_sdk_python-0.1.514 → codemie_sdk_python-0.1.516}/src/codemie_sdk/services/workflow.py

@@ -11,6 +11,8 @@ from ..models.workflow import (
     WorkflowCreateRequest,
     WorkflowUpdateRequest,
     WorkflowEvaluationRequest,
+    WorkflowGeneratorRequest,
+    WorkflowGeneratorResponse,
     Workflow,
 )
 from ..utils import ApiRequestHandler, TokenSource
@@ -56,6 +58,45 @@ class WorkflowService:
         """
         return self._api.post("/v1/workflows", dict, json_data=request.model_dump())
 
+    def generate(
+        self,
+        text: str,
+        llm_model: str | None = None,
+        persist: bool = False,
+        guardrail_ids: list[str] | None = None,
+    ) -> WorkflowGeneratorResponse:
+        """Generate a workflow configuration from a natural language description.
+
+        Args:
+            text: Natural language description of the desired workflow.
+            llm_model: Optional LLM model to use for generation. Falls back to
+                the platform default (``WORKFLOW_GENERATOR_LLM_MODEL`` or the
+                global default LLM) when not provided.
+            persist: When True, the generated workflow is validated
+                (``WorkflowExecutor.validate_workflow``) and saved on the
+                backend, and the response includes ``workflow_id``. When False
+                (default), only the in-memory ``workflow_config`` is returned
+                for client-side review/edit before an explicit
+                ``create_workflow`` call.
+            guardrail_ids: Optional guardrail IDs to attach to the generated
+                workflow's guardrail assignments.
+
+        Returns:
+            WorkflowGeneratorResponse containing the generated ``workflow_config``
+            and, when ``persist=True``, the created ``workflow_id``.
+        """
+        request = WorkflowGeneratorRequest(
+            text=text,
+            llm_model=llm_model,
+            persist=persist,
+            guardrail_ids=guardrail_ids,
+        )
+        return self._api.post(
+            "/v1/workflows/generate",
+            WorkflowGeneratorResponse,
+            json_data=request.model_dump(exclude_none=True),
+        )
+
     def update(self, workflow_id: str, request: WorkflowUpdateRequest) -> dict:
         """Update an existing workflow.