codemie-sdk-python 0.1.432__tar.gz → 0.1.434__tar.gz

{codemie_sdk_python-0.1.432 → codemie_sdk_python-0.1.434}/PKG-INFO

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

{codemie_sdk_python-0.1.432 → codemie_sdk_python-0.1.434}/pyproject.toml

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

{codemie_sdk_python-0.1.432 → codemie_sdk_python-0.1.434}/src/codemie_sdk/auth/credentials.py

@@ -1,10 +1,73 @@
 """Authentication credentials module for CodeMie SDK."""
 
+import base64
+import json as _json
 import time
 import requests
 from typing import Callable
 
 
+def _decode_jwt_exp(token: str) -> float | None:
+    """Return the exp claim from a JWT payload without signature verification."""
+    try:
+        parts = token.split(".")
+        if len(parts) != 3:
+            return None
+        payload = parts[1]
+        padding = 4 - len(payload) % 4
+        if padding != 4:
+            payload += "=" * padding
+        claims = _json.loads(base64.urlsafe_b64decode(payload))
+        exp = claims.get("exp")
+        return float(exp) if exp is not None else None
+    except Exception:
+        return None
+
+
+class LocalAuthCredentials:
+    """Authenticates against the backend local-auth endpoint and caches the JWT."""
+
+    _TOKEN_EXPIRY_BUFFER_SECONDS = 30
+
+    def __init__(
+        self,
+        api_domain: str,
+        email: str,
+        password: str,
+        verify_ssl: bool = True,
+    ):
+        self._login_url = f"{api_domain.rstrip('/')}/v1/local-auth/login"
+        self._email = email
+        self._password = password
+        self._verify_ssl = verify_ssl
+        self._cached_token: str | None = None
+        self._token_expires_at: float = 0.0
+
+    def get_token(self) -> str:
+        """Return cached JWT, re-logging in when expired."""
+        now = time.monotonic()
+        if self._cached_token and now < self._token_expires_at:
+            return self._cached_token
+
+        response = requests.post(
+            self._login_url,
+            json={"email": self._email, "password": self._password},
+            verify=self._verify_ssl,
+        )
+        response.raise_for_status()
+        self._cached_token = response.json()["access_token"]
+
+        exp = _decode_jwt_exp(self._cached_token)
+        if exp is not None:
+            ttl = exp - time.time()
+            self._token_expires_at = now + max(
+                ttl - self._TOKEN_EXPIRY_BUFFER_SECONDS, 0
+            )
+        else:
+            self._token_expires_at = now + 3570  # 1 h fallback
+        return self._cached_token
+
+
 class KeycloakCredentials:
     """Keycloak authentication credentials handler."""
 

{codemie_sdk_python-0.1.432 → codemie_sdk_python-0.1.434}/src/codemie_sdk/client/client.py

@@ -2,7 +2,7 @@
 
 from typing import Callable
 
-from ..auth.credentials import KeycloakCredentials
+from ..auth.credentials import KeycloakCredentials, LocalAuthCredentials
 from ..services.admin import AdminService
 from ..services.analytics import AnalyticsService
 from ..services.assistant import AssistantService
@@ -56,18 +56,6 @@ class CodeMieClient:
             external_idp: Identity provider ID to validate extern_token with (optional, required if using external_token)
             verify_ssl: Whether to verify SSL certificates (default: True)
         """
-        self.auth = KeycloakCredentials(
-            server_url=auth_server_url,
-            realm_name=auth_realm_name,
-            client_id=auth_client_id,
-            client_secret=auth_client_secret,
-            username=username,
-            password=password,
-            external_token=external_token,
-            external_idp=external_idp,
-            verify_ssl=verify_ssl,
-        )
-
         self._token: str | None = None
         self._api_domain = codemie_api_domain.rstrip("/")
         self._is_localhost = self._is_localhost_domain(self._api_domain)
@@ -78,10 +66,34 @@ class CodeMieClient:
 
             requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
 
-        # Initialize token; keep string copy for backward-compat callers reading _token directly
-        self._token = "" if self._is_localhost else self.auth.get_token()
-        # Services receive the bound method so each request resolves a fresh (cached) token
-        _token_source = "" if self._is_localhost else self.auth.get_token
+        if self._is_localhost and username and password:
+            self._local_auth: LocalAuthCredentials | None = LocalAuthCredentials(
+                api_domain=codemie_api_domain,
+                email=username,
+                password=password,
+                verify_ssl=verify_ssl,
+            )
+            self._token = self._local_auth.get_token()
+            _token_source = self._local_auth.get_token
+        elif self._is_localhost:
+            self._local_auth = None
+            self._token = ""
+            _token_source = ""
+        else:
+            self._local_auth = None
+            self.auth = KeycloakCredentials(
+                server_url=auth_server_url,
+                realm_name=auth_realm_name,
+                client_id=auth_client_id,
+                client_secret=auth_client_secret,
+                username=username,
+                password=password,
+                external_token=external_token,
+                external_idp=external_idp,
+                verify_ssl=verify_ssl,
+            )
+            self._token = self.auth.get_token()
+            _token_source = self.auth.get_token
 
         # Initialize services with verify_ssl parameter and token
         self.admin = AdminService(
@@ -145,7 +157,10 @@ class CodeMieClient:
     @property
     def token(self) -> str:
         """Get current token or fetch new one if not available."""
-        self._token = "" if self._is_localhost else self.auth.get_token()
+        if self._is_localhost and self._local_auth:
+            self._token = self._local_auth.get_token()
+        elif not self._is_localhost:
+            self._token = self.auth.get_token()
         return self._token
 
     @staticmethod
@@ -162,9 +177,14 @@ class CodeMieClient:
 
     def refresh_token(self) -> str:
         """Force token refresh."""
-        # Invalidate cache so next get_token() call re-fetches from Keycloak
-        self.auth._cached_token = None
-        self.auth._token_expires_at = 0.0
-        self._token = "" if self._is_localhost else self.auth.get_token()
-        # Services already hold self.auth.get_token callable, so no reconstruction needed
+        if self._is_localhost and self._local_auth:
+            self._local_auth._cached_token = None
+            self._local_auth._token_expires_at = 0.0
+            self._token = self._local_auth.get_token()
+        elif self._is_localhost:
+            self._token = ""
+        else:
+            self.auth._cached_token = None
+            self.auth._token_expires_at = 0.0
+            self._token = self.auth.get_token()
         return self._token

codemie_sdk_python-0.1.434/src/codemie_sdk/models/admin.py

@@ -0,0 +1,87 @@
+"""Admin models for managing applications/projects."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ApplicationsListResponse(BaseModel):
+    """Response model for list applications endpoint."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    applications: list[str] = Field(..., description="List of application names")
+
+
+class ApplicationCreateRequest(BaseModel):
+    """Request model for creating an application/project."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    name: str = Field(..., description="Application/project name")
+
+
+class ApplicationCreateResponse(BaseModel):
+    """Response model for create application endpoint."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    message: str = Field(..., description="Created application name")
+
+
+class LocalUserCreateRequest(BaseModel):
+    """Request model for admin user creation (local auth mode only)."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    email: str
+    username: str
+    password: str
+    name: str | None = None
+    is_admin: bool = False
+    is_maintainer: bool = False
+
+
+class LocalUserDetail(BaseModel):
+    """Response model for created/fetched user (local auth mode)."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str
+    email: str
+    username: str
+
+
+class AdminUserListItem(BaseModel):
+    """User item returned by the admin list-users endpoint."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str
+    email: str
+    username: str
+
+
+class AdminUserListPagination(BaseModel):
+    """Pagination metadata from GET /v1/admin/users."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    total: int
+    page: int
+    per_page: int
+
+
+class AdminUserListResponse(BaseModel):
+    """Paginated response from GET /v1/admin/users."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: list[AdminUserListItem]
+    pagination: AdminUserListPagination
+
+    @property
+    def users(self) -> list[AdminUserListItem]:
+        return self.data
+
+    @property
+    def total(self) -> int:
+        return self.pagination.total

{codemie_sdk_python-0.1.432 → codemie_sdk_python-0.1.434}/src/codemie_sdk/models/project.py

@@ -43,6 +43,24 @@ class ProjectMember(BaseModel):
     date: datetime | None = None
 
 
+class ProjectBudgetItem(BaseModel):
+    """Budget assigned to a project (present when include_budgets=true)."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    budget_id: str
+    name: str
+    budget_category: str
+    soft_budget: float
+    max_budget: float
+    budget_duration: str
+    budget_reset_at: datetime | None = None
+    provider_sync_status: str
+    member_count: int
+    allocated_member_budget_total: float
+    current_spending: float | None = None
+
+
 class ProjectListItem(BaseModel):
     """Project list response item."""
 
@@ -58,6 +76,8 @@ class ProjectListItem(BaseModel):
     counters: ProjectCounters | None = None
     cost_center_id: UUID | None = None
     cost_center_name: str | None = None
+    spending: float | None = None
+    budgets: list[ProjectBudgetItem] = []
 
 
 class PaginationInfo(BaseModel):
@@ -133,6 +153,7 @@ class ProjectUpdateRequest(BaseModel):
     description: str | None = None
     cost_center_id: UUID | None = None
     clear_cost_center: bool = False
+    project_member_budget_tracking_enabled: bool | None = None
 
 
 class ProjectDeleteResponse(BaseModel):

codemie_sdk_python-0.1.434/src/codemie_sdk/services/admin.py

@@ -0,0 +1,138 @@
+"""Admin service implementation."""
+
+from ..models.admin import (
+    AdminUserListItem,
+    AdminUserListResponse,
+    ApplicationsListResponse,
+    ApplicationCreateRequest,
+    ApplicationCreateResponse,
+    LocalUserCreateRequest,
+    LocalUserDetail,
+)
+from ..utils import ApiRequestHandler, TokenSource
+
+
+class AdminService:
+    """Service for managing CodeMie applications/projects."""
+
+    def __init__(self, api_domain: str, token: TokenSource, verify_ssl: bool = True):
+        """Initialize the admin 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 list_applications(self, project_name: str | None = None) -> list[str]:
+        """Get list of all applications/projects.
+
+        Args:
+            project_name: Optional project name to filter by
+
+        Returns:
+            List of application names
+        """
+        params = {}
+        if project_name:
+            params["search"] = project_name
+
+        response = self._api.get(
+            "/v1/admin/applications",
+            ApplicationsListResponse,
+            params=params if params else None,
+        )
+        return response.applications
+
+    def create_application(self, request: ApplicationCreateRequest) -> str:
+        """Create a new application/project.
+
+        Args:
+            request: Application creation request
+
+        Returns:
+            Created application name
+        """
+        response = self._api.post(
+            "/v1/admin/application",
+            ApplicationCreateResponse,
+            json_data=request.model_dump(exclude_none=True),
+        )
+        return response.message
+
+    def create_local_user(
+        self,
+        email: str,
+        username: str,
+        password: str,
+        name: str | None = None,
+        is_admin: bool = False,
+        is_maintainer: bool = False,
+    ) -> LocalUserDetail:
+        """Create a user via the admin API (local auth mode only).
+
+        Args:
+            email: User email address
+            username: Username (3-50 chars)
+            password: Initial password
+            name: Optional display name
+            is_admin: Grant admin role
+            is_maintainer: Grant maintainer role
+
+        Returns:
+            Created user details
+        """
+        request = LocalUserCreateRequest(
+            email=email,
+            username=username,
+            password=password,
+            name=name,
+            is_admin=is_admin,
+            is_maintainer=is_maintainer,
+        )
+        return self._api.post(
+            "/v1/admin/users",
+            LocalUserDetail,
+            json_data=request.model_dump(exclude_none=True),
+            wrap_response=False,
+        )
+
+    def list_users(
+        self,
+        search: str | None = None,
+        page: int = 0,
+        per_page: int = 20,
+    ) -> list[AdminUserListItem]:
+        """List users via the admin API.
+
+        Args:
+            search: Search string matched against email, username, name
+            page: 0-indexed page number
+            per_page: Page size
+
+        Returns:
+            List of user items
+        """
+        params: dict = {"page": page, "per_page": per_page}
+        if search:
+            params["search"] = search
+        response = self._api.get(
+            "/v1/admin/users",
+            AdminUserListResponse,
+            params=params,
+            wrap_response=False,
+        )
+        return response.users
+
+    def delete_user(self, user_id: str) -> None:
+        """Deactivate (soft-delete) a user via the admin API.
+
+        Args:
+            user_id: ID of the user to deactivate
+        """
+        self._api.delete(
+            f"/v1/admin/users/{user_id}",
+            dict,
+            wrap_response=False,
+        )

{codemie_sdk_python-0.1.432 → codemie_sdk_python-0.1.434}/src/codemie_sdk/services/project.py

@@ -86,6 +86,7 @@ class ProjectService:
         page: int = 0,
         per_page: int = 20,
         include_counters: bool = True,
+        include_budgets: bool = False,
         sort_by: Literal["name", "created_at"] | None = None,
         sort_order: Literal["asc", "desc"] = "asc",
     ) -> PaginatedProjectListResponse:
@@ -105,6 +106,7 @@ class ProjectService:
             "page": page,
             "per_page": per_page,
             "include_counters": include_counters,
+            "include_budgets": include_budgets,
             "sort_order": sort_order,
         }
 
@@ -147,6 +149,7 @@ class ProjectService:
         description: str | None = None,
         cost_center_id: UUID | None = None,
         clear_cost_center: bool = False,
+        project_member_budget_tracking_enabled: bool | None = None,
     ) -> ProjectUpdateResponse:
         """Update a project.
 
@@ -168,6 +171,7 @@ class ProjectService:
             description=description,
             cost_center_id=cost_center_id,
             clear_cost_center=clear_cost_center,
+            project_member_budget_tracking_enabled=project_member_budget_tracking_enabled,
         )
 
         return self._api.patch(

{codemie_sdk_python-0.1.432 → codemie_sdk_python-0.1.434}/src/codemie_sdk/utils/http.py

@@ -86,7 +86,7 @@ class ApiRequestHandler:
             headers["Content-Type"] = "application/json"
 
         if include_auth:
-            if self._is_localhost:
+            if self._is_localhost and not self._token:
                 headers["Authorization"] = "dev-codemie-user"
             else:
                 token_value = self._token() if callable(self._token) else self._token

codemie_sdk_python-0.1.432/src/codemie_sdk/models/admin.py

@@ -1,27 +0,0 @@
-"""Admin models for managing applications/projects."""
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class ApplicationsListResponse(BaseModel):
-    """Response model for list applications endpoint."""
-
-    model_config = ConfigDict(extra="ignore")
-
-    applications: list[str] = Field(..., description="List of application names")
-
-
-class ApplicationCreateRequest(BaseModel):
-    """Request model for creating an application/project."""
-
-    model_config = ConfigDict(extra="ignore")
-
-    name: str = Field(..., description="Application/project name")
-
-
-class ApplicationCreateResponse(BaseModel):
-    """Response model for create application endpoint."""
-
-    model_config = ConfigDict(extra="ignore")
-
-    message: str = Field(..., description="Created application name")

codemie_sdk_python-0.1.432/src/codemie_sdk/services/admin.py

@@ -1,58 +0,0 @@
-"""Admin service implementation."""
-
-from ..models.admin import (
-    ApplicationsListResponse,
-    ApplicationCreateRequest,
-    ApplicationCreateResponse,
-)
-from ..utils import ApiRequestHandler, TokenSource
-
-
-class AdminService:
-    """Service for managing CodeMie applications/projects."""
-
-    def __init__(self, api_domain: str, token: TokenSource, verify_ssl: bool = True):
-        """Initialize the admin 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 list_applications(self, project_name: str | None = None) -> list[str]:
-        """Get list of all applications/projects.
-
-        Args:
-            project_name: Optional project name to filter by
-
-        Returns:
-            List of application names
-        """
-        params = {}
-        if project_name:
-            params["search"] = project_name
-
-        response = self._api.get(
-            "/v1/admin/applications",
-            ApplicationsListResponse,
-            params=params if params else None,
-        )
-        return response.applications
-
-    def create_application(self, request: ApplicationCreateRequest) -> str:
-        """Create a new application/project.
-
-        Args:
-            request: Application creation request
-
-        Returns:
-            Created application name
-        """
-        response = self._api.post(
-            "/v1/admin/application",
-            ApplicationCreateResponse,
-            json_data=request.model_dump(exclude_none=True),
-        )
-        return response.message