codemie-sdk-python 0.1.286__tar.gz → 0.1.288__tar.gz

{codemie_sdk_python-0.1.286 → codemie_sdk_python-0.1.288}/PKG-INFO

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

{codemie_sdk_python-0.1.286 → codemie_sdk_python-0.1.288}/pyproject.toml

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

{codemie_sdk_python-0.1.286 → codemie_sdk_python-0.1.288}/src/codemie_sdk/__init__.py

@@ -79,11 +79,27 @@ from .models.guardrails import (
     GuardrailAssignmentRequest,
     GuardrailAssignmentResponse,
 )
+from .models.analytics import (
+    ResponseMetadata,
+    PaginationMetadata,
+    ColumnDefinition,
+    Metric,
+    SummariesData,
+    TabularData,
+    UserListItem,
+    UsersListData,
+    SummariesResponse,
+    TabularResponse,
+    UsersListResponse,
+    AnalyticsQueryParams,
+    PaginatedAnalyticsQueryParams,
+)
 from .services.vendor_assistant import VendorAssistantService
 from .services.vendor_workflow import VendorWorkflowService
 from .services.vendor_knowledgebase import VendorKnowledgeBaseService
 from .services.vendor_guardrail import VendorGuardrailService
 from .services.codemie_guardrails import CodemieGuardrailService
+from .services.analytics import AnalyticsService
 
 __version__ = "0.2.12"
 __all__ = [
@@ -144,4 +160,18 @@ __all__ = [
     "GuardrailAssignmentRequest",
     "GuardrailAssignmentResponse",
     "CodemieGuardrailService",
+    "ResponseMetadata",
+    "PaginationMetadata",
+    "ColumnDefinition",
+    "Metric",
+    "SummariesData",
+    "TabularData",
+    "UserListItem",
+    "UsersListData",
+    "SummariesResponse",
+    "TabularResponse",
+    "UsersListResponse",
+    "AnalyticsQueryParams",
+    "PaginatedAnalyticsQueryParams",
+    "AnalyticsService",
 ]

{codemie_sdk_python-0.1.286 → codemie_sdk_python-0.1.288}/src/codemie_sdk/client/client.py

@@ -4,6 +4,7 @@ from typing import Optional
 
 from ..auth.credentials import KeycloakCredentials
 from ..services.admin import AdminService
+from ..services.analytics import AnalyticsService
 from ..services.assistant import AssistantService
 from ..services.conversation import ConversationService
 from ..services.datasource import DatasourceService
@@ -72,6 +73,9 @@ class CodeMieClient:
 
         # Initialize services with verify_ssl parameter and token
         self.admin = AdminService(self._api_domain, self._token, verify_ssl=verify_ssl)
+        self.analytics = AnalyticsService(
+            self._api_domain, self._token, verify_ssl=verify_ssl
+        )
         self.assistants = AssistantService(
             self._api_domain, self._token, verify_ssl=verify_ssl
         )
@@ -137,6 +141,9 @@ class CodeMieClient:
         self.admin = AdminService(
             self._api_domain, self._token, verify_ssl=self._verify_ssl
         )
+        self.analytics = AnalyticsService(
+            self._api_domain, self._token, verify_ssl=self._verify_ssl
+        )
         self.assistants = AssistantService(
             self._api_domain, self._token, verify_ssl=self._verify_ssl
         )

codemie_sdk_python-0.1.288/src/codemie_sdk/models/analytics.py

@@ -0,0 +1,148 @@
+"""Models for analytics-related data structures."""
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ResponseMetadata(BaseModel):
+    """Metadata for analytics responses."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    timestamp: str = Field(description="ISO 8601 timestamp when response generated")
+    data_as_of: str = Field(description="ISO 8601 timestamp of data freshness")
+    filters_applied: Dict[str, Any] = Field(description="Applied filters")
+    execution_time_ms: float = Field(description="Query execution time in milliseconds")
+
+
+class PaginationMetadata(BaseModel):
+    """Pagination metadata for tabular responses."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    page: int = Field(description="Zero-indexed page number")
+    per_page: int = Field(description="Items per page")
+    total_count: int = Field(description="Total items available")
+    has_more: bool = Field(description="Whether more pages exist")
+
+
+class ColumnDefinition(BaseModel):
+    """Column metadata for tabular data."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str = Field(description="Column identifier")
+    label: str = Field(description="Human-readable label")
+    type: str = Field(description='Data type: "string", "number", "date"')
+    format: Optional[str] = Field(
+        None, description='Format hint: "currency", "percentage", "timestamp"'
+    )
+    description: Optional[str] = Field(None, description="Column description")
+
+
+class Metric(BaseModel):
+    """Individual metric in summary responses."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str = Field(description="Metric identifier")
+    label: str = Field(description="Human-readable label")
+    type: str = Field(description="Data type")
+    value: Any = Field(description="Metric value (int, float, str, etc.)")
+    format: Optional[str] = Field(
+        None, description='Format hint: "currency", "percentage", "number"'
+    )
+    description: Optional[str] = Field(None, description="Metric description")
+
+
+class SummariesData(BaseModel):
+    """Container for summary metrics."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    metrics: List[Metric] = Field(description="Array of metrics")
+
+
+class TabularData(BaseModel):
+    """Container for tabular data with dynamic columns."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    columns: List[ColumnDefinition] = Field(description="Column definitions")
+    rows: List[Dict[str, Any]] = Field(description="Data rows (dict per row)")
+    totals: Optional[Dict[str, Any]] = Field(None, description="Optional totals row")
+
+
+class UserListItem(BaseModel):
+    """Individual user item."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str = Field(description="User ID")
+    name: str = Field(description="User name")
+
+
+class UsersListData(BaseModel):
+    """Container for users list."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    users: List[UserListItem] = Field(description="List of users")
+    total_count: int = Field(description="Total number of users")
+
+
+class SummariesResponse(BaseModel):
+    """Response for summary endpoints (summaries, cli-summary)."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: SummariesData = Field(description="Summary data")
+    metadata: ResponseMetadata = Field(description="Response metadata")
+
+
+class TabularResponse(BaseModel):
+    """Response for tabular endpoints (19 endpoints)."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: TabularData = Field(description="Tabular data")
+    metadata: ResponseMetadata = Field(description="Response metadata")
+    pagination: Optional[PaginationMetadata] = Field(
+        None, description="Optional pagination metadata"
+    )
+
+
+class UsersListResponse(BaseModel):
+    """Response for users list endpoint."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: UsersListData = Field(description="Users list data")
+    metadata: ResponseMetadata = Field(description="Response metadata")
+
+
+class AnalyticsQueryParams(BaseModel):
+    """Query parameters for analytics endpoints."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    time_period: Optional[str] = Field(
+        None,
+        description='Time period: "last_hour", "last_6_hours", "last_24_hours", "last_7_days", "last_30_days", "last_90_days", "last_year"',
+    )
+    start_date: Optional[str] = Field(
+        None, description="ISO 8601 format start date (use with end_date)"
+    )
+    end_date: Optional[str] = Field(
+        None, description="ISO 8601 format end date (use with start_date)"
+    )
+    users: Optional[str] = Field(None, description="Comma-separated user IDs")
+    projects: Optional[str] = Field(None, description="Comma-separated project names")
+
+
+class PaginatedAnalyticsQueryParams(AnalyticsQueryParams):
+    """Query parameters with pagination."""
+
+    page: int = Field(0, description="Zero-indexed page number")
+    per_page: int = Field(20, description="Items per page")

codemie_sdk_python-0.1.288/src/codemie_sdk/services/analytics.py

@@ -0,0 +1,463 @@
+"""Analytics service implementation."""
+
+from typing import Optional
+
+from ..models.analytics import (
+    AnalyticsQueryParams,
+    PaginatedAnalyticsQueryParams,
+    SummariesResponse,
+    TabularResponse,
+    UsersListResponse,
+)
+from ..utils import ApiRequestHandler
+
+
+class AnalyticsService:
+    """Service for managing CodeMie analytics."""
+
+    def __init__(self, api_domain: str, token: str, verify_ssl: bool = True):
+        """Initialize the analytics 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_summaries(
+        self, params: Optional[AnalyticsQueryParams] = None
+    ) -> SummariesResponse:
+        """Get overall platform summary metrics.
+
+        Args:
+            params: Query parameters (time filters, user/project filters)
+
+        Returns:
+            SummariesResponse with metrics array including total input tokens,
+            cached input tokens, output tokens, and money spent
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/summaries",
+            SummariesResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_summary(
+        self, params: Optional[AnalyticsQueryParams] = None
+    ) -> SummariesResponse:
+        """Get CLI-specific summary metrics.
+
+        Args:
+            params: Query parameters (time filters, user/project filters)
+
+        Returns:
+            SummariesResponse with CLI metrics including unique users, repos,
+            sessions, file operations, and code statistics
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-summary",
+            SummariesResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_assistants_chats(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get assistants chats analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with assistant performance metrics including chat statistics,
+            error rates, token consumption, and costs
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/assistants-chats",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_workflows(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get workflows analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with workflow execution metrics including total runs,
+            success/failure rates, costs, and performance statistics
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/workflows",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_tools_usage(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get tool usage analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with tool usage metrics including invocation counts,
+            user adoption, agent usage, and error tracking
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/tools-usage",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_webhooks_invocation(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get webhooks invocation statistics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with webhook usage patterns showing invocation counts
+            per user and webhook alias
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/webhooks-invocation",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_mcp_servers(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top MCP servers analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with MCP server usage distribution showing
+            percentage share of each server
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/mcp-servers",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_mcp_servers_by_users(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get MCP servers usage by users.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with individual user adoption and usage of MCP servers
+            showing which users are utilizing which servers
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/mcp-servers-by-users",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_projects_spending(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get money spent by projects.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with project-level spending ranked by amount
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/projects-spending",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_llms_usage(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top LLMs usage analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with LLM model usage distribution showing
+            preference patterns across different models
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/llms-usage",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_users_spending(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get money spent by users.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with individual user spending ranked by amount
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/users-spending",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_budget_soft_limit(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get soft budget limit violations.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with users who have exceeded soft budget limits
+            (warning threshold)
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/budget-soft-limit",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_budget_hard_limit(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get hard budget limit violations.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with users who have reached or exceeded hard budget
+            limits (enforcement threshold)
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/budget-hard-limit",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_users_activity(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get most active users analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with comprehensive user activity metrics including
+            spending, recent projects, and token consumption
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/users-activity",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_projects_activity(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get most active projects analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with project activity metrics including spending,
+            active user counts, and token consumption
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/projects-activity",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_agents_usage(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top agents usage analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with agent usage analytics including invocations,
+            spending, user adoption, tool usage, and error tracking
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/agents-usage",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_agents(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top CLI agents analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with CLI agent usage distribution showing
+            percentage share of each agent
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-agents",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_llms(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top CLI LLMs analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with LLM model usage distribution in CLI context
+            showing percentage share
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-llms",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_users(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get most active CLI users analytics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with CLI user activity showing total invocation
+            counts per user
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-users",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_errors(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get top error codes for CLI.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with most common CLI error codes with occurrence
+            counts for troubleshooting
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-errors",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_cli_repositories(
+        self, params: Optional[PaginatedAnalyticsQueryParams] = None
+    ) -> TabularResponse:
+        """Get repository statistics.
+
+        Args:
+            params: Query parameters (filters + pagination)
+
+        Returns:
+            TabularResponse with repository-level metrics including code changes,
+            token consumption, and branch activity
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/cli-repositories",
+            TabularResponse,
+            params=query_params,
+            wrap_response=False,
+        )
+
+    def get_users(
+        self, params: Optional[AnalyticsQueryParams] = None
+    ) -> UsersListResponse:
+        """Get users list.
+
+        Args:
+            params: Query parameters (time filters, user/project filters)
+
+        Returns:
+            UsersListResponse with list of unique users
+        """
+        query_params = params.model_dump(exclude_none=True) if params else {}
+        return self._api.get(
+            "/v1/analytics/users",
+            UsersListResponse,
+            params=query_params,
+            wrap_response=False,
+        )