codemie-sdk-python 0.1.705__tar.gz → 0.1.706__tar.gz

{codemie_sdk_python-0.1.705 → codemie_sdk_python-0.1.706}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codemie-sdk-python
-Version: 0.1.705
+Version: 0.1.706
 Summary: CodeMie SDK for Python
 License: Apache-2.0
 Author: CodeMie

{codemie_sdk_python-0.1.705 → codemie_sdk_python-0.1.706}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "codemie-sdk-python"
-version = "0.1.705"
+version = "0.1.706"
 description = "CodeMie SDK for Python"
 authors = ["CodeMie"]
 license = "Apache-2.0"

{codemie_sdk_python-0.1.705 → codemie_sdk_python-0.1.706}/src/codemie_sdk/__init__.py

@@ -175,6 +175,16 @@ from .models.a2a import (
     AgentSkill,
 )
 from .services.a2a import A2AService
+from .models.usage_attribution import (
+    UsageAttributionQueryParams,
+    UsageAttributionRange,
+    UsageAttributionAnalysisSettings,
+    UsageAttributionAnalysis,
+    UsageAttributionResponse,
+    UsageAttributionTableResponse,
+    UsageAttributionSettingsResponse,
+)
+from .services.usage_attribution import UsageAttributionService
 
 try:
     __version__ = _pkg_version("codemie-sdk-python")
@@ -311,4 +321,12 @@ __all__ = [
     "AgentCapabilities",
     "AgentSkill",
     "A2AService",
+    "UsageAttributionQueryParams",
+    "UsageAttributionRange",
+    "UsageAttributionAnalysisSettings",
+    "UsageAttributionAnalysis",
+    "UsageAttributionResponse",
+    "UsageAttributionTableResponse",
+    "UsageAttributionSettingsResponse",
+    "UsageAttributionService",
 ]

{codemie_sdk_python-0.1.705 → codemie_sdk_python-0.1.706}/src/codemie_sdk/client/client.py

@@ -33,6 +33,7 @@ from ..services.mcp_configs import MCPConfigsService
 from ..services.cost_center import CostCenterService
 from ..services.customer_config_service import CustomerConfigService
 from ..services.project_budget_groups import ProjectBudgetGroupsService
+from ..services.usage_attribution import UsageAttributionService
 from ..services.servicenow_integration import ServiceNowIntegrationService
 
 
@@ -193,6 +194,9 @@ class CodeMieClient:
         self.workspaces = WorkspaceService(
             self._api_domain, _token_source, verify_ssl=self._verify_ssl
         )
+        self.usage_attribution = UsageAttributionService(
+            self._api_domain, _token_source, verify_ssl=self._verify_ssl
+        )
 
     @property
     def token(self) -> str:

codemie_sdk_python-0.1.706/src/codemie_sdk/models/usage_attribution.py

@@ -0,0 +1,124 @@
+# Copyright 2026 EPAM Systems, Inc. ("EPAM")
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Usage Attribution analytics models for the CodeMie SDK."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .analytics import PaginationMetadata
+
+
+class UsageAttributionQueryParams(BaseModel):
+    """Period parameters shared by the Usage Attribution read endpoints.
+
+    The endpoints take no project or user filter: they always attribute all usage.
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    time_period: str | None = Field(
+        None,
+        description='Time period: "last_hour", "last_6_hours", "last_24_hours", "last_7_days", "last_30_days", "last_60_days", "last_year"',
+    )
+    start_date: str | None = Field(
+        None, description="ISO 8601 start date (use with end_date)"
+    )
+    end_date: str | None = Field(
+        None, description="ISO 8601 end date (use with start_date)"
+    )
+
+
+class UsageAttributionRange(BaseModel):
+    """The effective range of a response; ranges longer than the maximum are clamped."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    from_: str = Field(alias="from", description="Effective start")
+    to: str = Field(description="Effective end")
+    days: float = Field(description="Length of the effective range in days")
+    clamped: bool = Field(description="The requested range was cut to the maximum")
+    requested_from: str | None = Field(None, description="Requested start")
+    requested_to: str | None = Field(None, description="Requested end")
+    evidence_from: str | None = Field(
+        None, description="Start of the evidence window used for categories"
+    )
+
+
+class UsageAttributionAnalysisSettings(BaseModel):
+    """The analysis settings behind a response."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    hash: str | None = None
+    defaults_hash: str | None = None
+    schema_version: int | None = None
+    overridden: list[str] = Field(default_factory=list)
+    tier: str | None = None
+
+
+class UsageAttributionAnalysis(BaseModel):
+    """When and how the cached analysis behind a response was computed."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    computed_at: str | None = None
+    duration_ms: float | None = None
+    cache: str = Field(description="hit, miss, shared or stale")
+    stale: bool = False
+    refreshing: bool = Field(False, description="A newer analysis is being computed")
+    error: str | None = None
+    ttl_s: int | None = None
+    window: dict[str, Any] | None = None
+    evidence_window: dict[str, Any] | None = None
+    coverage: dict[str, Any] | None = None
+    unclassified_reasons: dict[str, Any] | None = None
+    allocated: float | None = None
+    timings: dict[str, Any] = Field(default_factory=dict)
+    settings: UsageAttributionAnalysisSettings | None = None
+
+
+class UsageAttributionResponse(BaseModel):
+    """A composite view: totals, tiles, charts, a popup or How It Works."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: dict[str, Any]
+    range: UsageAttributionRange | None = None
+    analysis: UsageAttributionAnalysis | None = Field(
+        None, description="Absent for the fast totals, which skip the analysis"
+    )
+
+
+class UsageAttributionTableResponse(BaseModel):
+    """A table page: rows of the page, totals over every matching row and filter counts."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: dict[str, Any] = Field(description="rows and totals")
+    pagination: PaginationMetadata
+    counts: dict[str, int] = Field(default_factory=dict)
+    threshold: float | None = None
+    display: dict[str, float] | None = None
+    range: UsageAttributionRange
+    analysis: UsageAttributionAnalysis
+
+
+class UsageAttributionSettingsResponse(BaseModel):
+    """The tunable settings schema, the defaults and whether the caller may tune."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: dict[str, Any]

codemie_sdk_python-0.1.706/src/codemie_sdk/services/usage_attribution.py

@@ -0,0 +1,324 @@
+# Copyright 2026 EPAM Systems, Inc. ("EPAM")
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Usage Attribution analytics service for the CodeMie SDK.
+
+Wraps the read endpoints under ``/v1/analytics/usage-attribution``, available to
+admins, maintainers and auditors when the ``features:usageAttribution`` flag is on.
+"""
+
+from typing import Any
+from urllib.parse import quote
+
+from ..models.usage_attribution import (
+    UsageAttributionQueryParams,
+    UsageAttributionResponse,
+    UsageAttributionSettingsResponse,
+    UsageAttributionTableResponse,
+)
+from ..utils import ApiRequestHandler, TokenSource
+
+_BASE = "/v1/analytics/usage-attribution"
+
+
+class UsageAttributionService:
+    """Service for reading Usage Attribution analytics: who pays for Web Platform and CLI usage."""
+
+    def __init__(self, api_domain: str, token: TokenSource, verify_ssl: bool = True):
+        """Initialize the usage attribution 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)
+
+    @staticmethod
+    def _query(
+        params: UsageAttributionQueryParams | None, **extra: Any
+    ) -> dict[str, Any]:
+        """Period parameters plus the extra ones that were given (None means the server default)."""
+        query = params.model_dump(exclude_none=True) if params else {}
+        query.update({key: value for key, value in extra.items() if value is not None})
+        return query
+
+    def _get_view(
+        self,
+        path: str,
+        params: UsageAttributionQueryParams | None = None,
+        **extra: Any,
+    ) -> UsageAttributionResponse:
+        return self._api.get(
+            f"{_BASE}{path}",
+            UsageAttributionResponse,
+            params=self._query(params, **extra),
+            wrap_response=False,
+        )
+
+    def _get_table(
+        self,
+        path: str,
+        params: UsageAttributionQueryParams | None = None,
+        **extra: Any,
+    ) -> UsageAttributionTableResponse:
+        return self._api.get(
+            f"{_BASE}{path}",
+            UsageAttributionTableResponse,
+            params=self._query(params, **extra),
+            wrap_response=False,
+        )
+
+    def get_totals(
+        self, params: UsageAttributionQueryParams | None = None
+    ) -> UsageAttributionResponse:
+        """Get the fast totals: Total, Web Platform, CLI, Charged Back and Who Pays.
+
+        Args:
+            params: Period parameters
+
+        Returns:
+            UsageAttributionResponse whose data holds the amounts. The analysis
+            block is absent for this view.
+
+        Raises:
+            requests.HTTPError: 403 without an allowed role, 404 when the feature is off
+        """
+        return self._get_view("/totals", params)
+
+    def get_status(
+        self, params: UsageAttributionQueryParams | None = None
+    ) -> UsageAttributionResponse:
+        """Get How It Works: coverage, data quality, run details and the settings in effect.
+
+        Args:
+            params: Period parameters
+
+        Returns:
+            UsageAttributionResponse with the analysis block
+        """
+        return self._get_view("/status", params)
+
+    def get_cli_summary(
+        self, params: UsageAttributionQueryParams | None = None
+    ) -> UsageAttributionResponse:
+        """Get the CLI categories: tiles, Who Pays and CLI spend by category.
+
+        Args:
+            params: Period parameters
+
+        Returns:
+            UsageAttributionResponse with tiles, who_pays, categories and the analysis block
+        """
+        return self._get_view("/cli-summary", params)
+
+    def get_settings(self) -> UsageAttributionSettingsResponse:
+        """Get the analysis settings: defaults, tunable schema and what the caller may do.
+
+        Returns:
+            UsageAttributionSettingsResponse, whose data carries ``can_tune`` and ``can_refresh``
+        """
+        return self._api.get(
+            f"{_BASE}/settings",
+            UsageAttributionSettingsResponse,
+            wrap_response=False,
+        )
+
+    def get_shared_projects(
+        self,
+        params: UsageAttributionQueryParams | None = None,
+        scope: str | None = None,
+        search: str | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> UsageAttributionTableResponse:
+        """List shared projects without a budget.
+
+        Args:
+            params: Period parameters
+            scope: "threshold" (default) or "all"
+            search: Case-insensitive text to find in the project name
+            page: Zero-indexed page number
+            per_page: Items per page
+            sort_by: Column to sort by
+            sort_order: "asc" or "desc"
+
+        Returns:
+            UsageAttributionTableResponse with the rows of the page and the filter counts
+        """
+        return self._get_table(
+            "/shared-projects",
+            params,
+            scope=scope,
+            search=search,
+            page=page,
+            per_page=per_page,
+            sort_by=sort_by,
+            sort_order=sort_order,
+        )
+
+    def get_shared_project(
+        self,
+        project_name: str,
+        params: UsageAttributionQueryParams | None = None,
+    ) -> UsageAttributionResponse:
+        """Get the popup of one shared project.
+
+        Args:
+            project_name: Name of the project
+            params: Period parameters
+
+        Returns:
+            UsageAttributionResponse whose data holds ``row`` and ``detail``
+
+        Raises:
+            requests.HTTPError: 404 when the project is not in the analysis of the period
+        """
+        return self._get_view(
+            f"/shared-projects/{quote(project_name, safe='')}", params
+        )
+
+    def get_repository_groups(
+        self,
+        params: UsageAttributionQueryParams | None = None,
+        scope: str | None = None,
+        search: str | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> UsageAttributionTableResponse:
+        """List repository groups in personal projects.
+
+        Args:
+            params: Period parameters
+            scope: "threshold" (default) or "all"
+            search: Case-insensitive text to find in the group name or its repositories
+            page: Zero-indexed page number
+            per_page: Items per page
+            sort_by: Column to sort by
+            sort_order: "asc" or "desc"
+
+        Returns:
+            UsageAttributionTableResponse with the rows of the page and the filter counts
+        """
+        return self._get_table(
+            "/repository-groups",
+            params,
+            scope=scope,
+            search=search,
+            page=page,
+            per_page=per_page,
+            sort_by=sort_by,
+            sort_order=sort_order,
+        )
+
+    def get_repository_group(
+        self,
+        group_id: str,
+        params: UsageAttributionQueryParams | None = None,
+    ) -> UsageAttributionResponse:
+        """Get the popup of one repository group.
+
+        Args:
+            group_id: Group id as listed by get_repository_groups
+            params: Period parameters
+
+        Returns:
+            UsageAttributionResponse whose data holds ``row`` and ``detail``
+
+        Raises:
+            requests.HTTPError: 404 when the group is not in the analysis of the period
+        """
+        return self._get_view(f"/repository-groups/{quote(group_id, safe='')}", params)
+
+    def get_people(
+        self,
+        params: UsageAttributionQueryParams | None = None,
+        filter: str | None = None,
+        search: str | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> UsageAttributionTableResponse:
+        """List people with their spend.
+
+        Args:
+            params: Period parameters
+            filter: "all" (default), "cand", "prod", "exp", "shared" or "platform"
+            search: Case-insensitive text to find in the name, e-mail or main repository
+            page: Zero-indexed page number
+            per_page: Items per page
+            sort_by: Column to sort by
+            sort_order: "asc" or "desc"
+
+        Returns:
+            UsageAttributionTableResponse with the rows of the page and a count per filter
+        """
+        return self._get_table(
+            "/people",
+            params,
+            filter=filter,
+            search=search,
+            page=page,
+            per_page=per_page,
+            sort_by=sort_by,
+            sort_order=sort_order,
+        )
+
+    def get_person(
+        self,
+        user_id: str,
+        params: UsageAttributionQueryParams | None = None,
+    ) -> UsageAttributionResponse:
+        """Get the popup of one person.
+
+        Args:
+            user_id: User id as listed by get_people
+            params: Period parameters
+
+        Returns:
+            UsageAttributionResponse whose data holds ``row`` and ``detail``
+
+        Raises:
+            requests.HTTPError: 404 when the person is not in the analysis of the period
+        """
+        return self._get_view(f"/people/{quote(user_id, safe='')}", params)
+
+    def get_breakdown(
+        self,
+        params: UsageAttributionQueryParams | None = None,
+        dimension: str | None = None,
+        category: str | None = None,
+    ) -> UsageAttributionResponse:
+        """Get CLI spend paid from personal budgets, by country or job title group.
+
+        Args:
+            params: Period parameters
+            dimension: "country" (default) or "job"
+            category: "production" (default), "learning", "testing", "experimental",
+                "pet_project" or "unclassified"
+
+        Returns:
+            UsageAttributionResponse whose data holds ``rows`` (label and spend) and ``total``
+
+        Raises:
+            requests.HTTPError: 404 when user enrichment is disabled
+        """
+        return self._get_view(
+            "/breakdown", params, dimension=dimension, category=category
+        )