gmicloud 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

gmicloud/__init__.py

@@ -1,3 +1,6 @@
+import logging
+import os
+
 from ._internal._models import (
     Artifact,
     ArtifactData,
@@ -16,7 +19,8 @@ from ._internal._models import (
 )
 from ._internal._enums import (
     BuildStatus,
-    TaskEndpointStatus
+    TaskEndpointStatus,
+    TaskStatus
 )
 from .client import Client
 
@@ -39,3 +43,10 @@ __all__ = [
     "BuildStatus",
     "TaskEndpointStatus",
 ]
+
+# Configure logging
+log_level = os.getenv("GMI_CLOUD_LOG_LEVEL", "INFO").upper()
+logging.basicConfig(
+    level=log_level,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)

gmicloud/_internal/_client/_artifact_client.py

@@ -1,4 +1,6 @@
 from typing import List
+import logging
+from requests.exceptions import RequestException
 
 from ._http_client import HTTPClient
 from ._iam_client import IAMClient
@@ -6,6 +8,8 @@ from ._decorator import handle_refresh_token
 from .._models import *
 from .._config import ARTIFACT_SERVICE_BASE_URL
 
+logger = logging.getLogger(__name__)
+
 
 class ArtifactClient:
     """
@@ -24,119 +28,185 @@ class ArtifactClient:
         self.iam_client = iam_client
 
     @handle_refresh_token
-    def get_artifact(self, artifact_id: str) -> Artifact:
+    def get_artifact(self, artifact_id: str) -> Optional[Artifact]:
         """
         Fetches an artifact by its ID.
 
         :param artifact_id: The ID of the artifact to fetch.
-        :return: The Artifact object.
-        :rtype: Artifact
-        """
-        result = self.client.get(f"/get_artifact", self.iam_client.get_custom_headers(), {"artifact_id": artifact_id})
-
-        return Artifact.model_validate(result)
+        :return: The Artifact object or None if an error occurs.
+        """
+        try:
+            response = self.client.get(
+                "/get_artifact",
+                self.iam_client.get_custom_headers(),
+                {"artifact_id": artifact_id}
+            )
+            return Artifact.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to fetch artifact {artifact_id}: {e}")
+            return None
 
     @handle_refresh_token
     def get_all_artifacts(self) -> List[Artifact]:
         """
         Fetches all artifacts.
 
-        :return: A list of Artifact objects.
-        :rtype: List[Artifact]
+        :return: A list of Artifact objects. If an error occurs, returns an empty list.
         """
-        result = self.client.get("/get_all_artifacts", self.iam_client.get_custom_headers())
-        if not result:
+        try:
+            response = self.client.get("/get_all_artifacts", self.iam_client.get_custom_headers())
+            if not response:
+                logger.error("Empty response from /get_all_artifacts")
+                return []
+            return [Artifact.model_validate(item) for item in response]
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to fetch all artifacts: {e}")
             return []
-        return [Artifact.model_validate(item) for item in result]
 
     @handle_refresh_token
-    def create_artifact(self, request: CreateArtifactRequest) -> CreateArtifactResponse:
+    def create_artifact(self, request: CreateArtifactRequest) -> Optional[CreateArtifactResponse]:
         """
         Creates a new artifact in the service.
 
         :param request: The request object containing artifact details.
-        :return: The response object containing the created artifact details.
-        :rtype: CreateArtifactResponse
-        """
-        result = self.client.post("/create_artifact", self.iam_client.get_custom_headers(), request.model_dump())
-
-        return CreateArtifactResponse.model_validate(result)
+        :return: The response object containing the created artifact details, or None on error.
+        """
+        try:
+            response = self.client.post(
+                "/create_artifact",
+                self.iam_client.get_custom_headers(),
+                request.model_dump()
+            )
+            return CreateArtifactResponse.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to create artifact: {e}")
+            return None
 
     @handle_refresh_token
-    def create_artifact_from_template(self, artifact_template_id: str) -> CreateArtifactFromTemplateResponse:
+    def create_artifact_from_template(self, artifact_template_id: str) -> Optional[CreateArtifactFromTemplateResponse]:
         """
         Creates a new artifact in the service.
 
         :param artifact_template_id: The ID of the artifact template to use.
-        :return: The response object containing the created artifact details.
-        :rtype: CreateArtifactFromTemplateResponse
-        """
-        result = self.client.post("/create_artifact_from_template", self.iam_client.get_custom_headers(),
-                                  {"artifact_template_id": artifact_template_id})
-
-        return CreateArtifactFromTemplateResponse.model_validate(result)
+        :return: The response object containing the created artifact details or None if an error occurs.
+        """
+        try:
+            response = self.client.post(
+                "/create_artifact_from_template",
+                self.iam_client.get_custom_headers(),
+                {"artifact_template_id": artifact_template_id}
+            )
+            return CreateArtifactFromTemplateResponse.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to create artifact from template {artifact_template_id}: {e}")
+            return None
 
     @handle_refresh_token
-    def rebuild_artifact(self, artifact_id: str) -> RebuildArtifactResponse:
+    def rebuild_artifact(self, artifact_id: str) -> Optional[RebuildArtifactResponse]:
         """
         Rebuilds an artifact in the service.
 
         :param artifact_id: The ID of the artifact to rebuild.
-        :return: The response object containing the rebuilt artifact details.
-        :rtype: RebuildArtifactResponse
-        """
-        result = self.client.post("/rebuild_artifact", self.iam_client.get_custom_headers(),
-                                  {"artifact_id": artifact_id})
-
-        return CreateArtifactResponse.model_validate(result)
+        :return: The response object containing the rebuilt artifact details or None if an error occurs.
+        """
+        try:
+            response = self.client.post(
+                "/rebuild_artifact",
+                self.iam_client.get_custom_headers(),
+                {"artifact_id": artifact_id}
+            )
+            return RebuildArtifactResponse.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to rebuild artifact {artifact_id}: {e}")
+            return None
 
     @handle_refresh_token
-    def delete_artifact(self, artifact_id: str) -> DeleteArtifactResponse:
+    def delete_artifact(self, artifact_id: str) -> Optional[DeleteArtifactResponse]:
         """
         Deletes an artifact by its ID.
 
         :param artifact_id: The ID of the artifact to delete.
-        :return: The response object containing the deleted artifact details.
-        :rtype: DeleteArtifactResponse
-        """
-        result = self.client.delete("/delete_artifact", self.iam_client.get_custom_headers(),
-                                    {"artifact_id": artifact_id})
-
-        return DeleteArtifactResponse.model_validate(result)
+        :return: The response object containing the deleted artifact details or None if an error occurs.
+        """
+        try:
+            response = self.client.delete(
+                "/delete_artifact",
+                self.iam_client.get_custom_headers(),
+                {"artifact_id": artifact_id}
+            )
+            return DeleteArtifactResponse.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to delete artifact {artifact_id}: {e}")
+            return None
 
     @handle_refresh_token
-    def get_bigfile_upload_url(self, request: GetBigFileUploadUrlRequest) -> GetBigFileUploadUrlResponse:
+    def get_bigfile_upload_url(self, request: GetBigFileUploadUrlRequest) -> Optional[GetBigFileUploadUrlResponse]:
         """
         Generates a pre-signed URL for uploading a large file.
 
         :param request: The request object containing the artifact ID, file name, and file type.
-        :return: The response object containing the pre-signed URL and upload details.
-        :rtype: GetBigFileUploadUrlResponse
+        :return: The response object containing the pre-signed URL and upload details, or None if an error occurs.
         """
-        result = self.client.post("/get_bigfile_upload_url", self.iam_client.get_custom_headers(), request.model_dump())
+        try:
+            response = self.client.post("/get_bigfile_upload_url",
+                                        self.iam_client.get_custom_headers(),
+                                        request.model_dump())
+
+            if not response:
+                logger.error("Empty response from /get_bigfile_upload_url")
+                return None
+
+            return GetBigFileUploadUrlResponse.model_validate(response)
 
-        return GetBigFileUploadUrlResponse.model_validate(result)
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to generate upload URL: {e}")
+            return None
 
     @handle_refresh_token
-    def delete_bigfile(self, request: DeleteBigfileRequest) -> DeleteBigfileResponse:
+    def delete_bigfile(self, request: DeleteBigfileRequest) -> Optional[DeleteBigfileResponse]:
         """
         Deletes a large file associated with an artifact.
 
         :param request: The request object containing the artifact ID and file name.
-        :return: The response object containing the deletion status.
-        :rtype: DeleteBigfileResponse
+        :return: The response object containing the deletion status, or None if an error occurs.
         """
-        result = self.client.delete("/delete_bigfile", self.iam_client.get_custom_headers(), request.dict())
+        try:
+            response = self.client.delete("/delete_bigfile",
+                                          self.iam_client.get_custom_headers(),
+                                          request.model_dump())
+
+            if not response:
+                logger.error("Empty response from /delete_bigfile")
+                return None
+
+            return DeleteBigfileResponse.model_validate(response)
 
-        return DeleteBigfileResponse.model_validate(result)
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to delete big file: {e}")
+            return None
 
     @handle_refresh_token
-    def get_artifact_templates(self) -> GetArtifactTemplatesResponse:
+    def get_public_templates(self) -> List[ArtifactTemplate]:
         """
         Fetches all artifact templates.
 
         :return: A list of ArtifactTemplate objects.
         :rtype: List[ArtifactTemplate]
         """
-        result = self.client.get("/get_artifact_templates", self.iam_client.get_custom_headers())
-        return GetArtifactTemplatesResponse.model_validate(result)
+        try:
+            response = self.client.get("/get_public_templates", self.iam_client.get_custom_headers())
+
+            if not response:
+                logger.error("Empty response received from /get_public_templates API")
+                return []
+
+            try:
+                result = GetPublicTemplatesResponse.model_validate(response)
+                return result.artifact_templates
+            except ValueError as ve:
+                logger.error(f"Failed to validate response data: {ve}")
+                return []
+
+        except RequestException as e:
+            logger.error(f"Request to /get_public_templates failed: {e}")
+            return []

gmicloud/_internal/_client/_http_client.py

@@ -1,8 +1,11 @@
+import logging
+
 import requests
 from .._exceptions import APIError
 from .._exceptions import UnauthorizedError
 from .._constants import *
-from .._config import *
+
+logger = logging.getLogger(__name__)
 
 
 class HTTPClient:
@@ -52,6 +55,7 @@ class HTTPClient:
         response = None
         try:
             response = requests.request(method, url, params=params, json=data, headers=headers)
+            logger.debug(response.text)
             if response.status_code == 401:
                 raise UnauthorizedError("Access token expired or invalid.")
             elif response.status_code != 200 and response.status_code != 201:
@@ -62,7 +66,6 @@ class HTTPClient:
                 raise APIError(f"HTTP Request failed: {error_message}")
             # Raise for HTTP errors
             response.raise_for_status()
-            print(response.text)
 
         except requests.exceptions.RequestException as e:
             raise APIError(f"HTTP Request failed: {str(e)}")

gmicloud/_internal/_client/_iam_client.py

@@ -1,10 +1,14 @@
 import jwt
+import logging
+from requests.exceptions import RequestException
 
 from ._http_client import HTTPClient
 from .._config import IAM_SERVICE_BASE_URL
 from .._models import *
 from .._constants import CLIENT_ID_HEADER, AUTHORIZATION_HEADER
 
+logger = logging.getLogger(__name__)
+
 
 class IAMClient:
     """
@@ -25,35 +29,113 @@ class IAMClient:
         self._access_token = ""
         self._refresh_token = ""
         self._user_id = ""
+        self._organization_id = ""
         self.client = HTTPClient(IAM_SERVICE_BASE_URL)
 
-    def login(self):
+    def login(self) -> bool:
         """
-        Logs in a user with the given username and password.
+        Logs in a user with the given email and password.
+        Returns True if login is successful, otherwise False.
         """
-        custom_headers = {
-            CLIENT_ID_HEADER: self._client_id
-        }
-        req = LoginRequest(email=self._email, password=self._password)
-        result = self.client.post("/me/sessions", custom_headers, req.model_dump())
+        try:
+            custom_headers = {CLIENT_ID_HEADER: self._client_id}
+            req = AuthTokenRequest(email=self._email, password=self._password)
+            auth_tokens_result = self.client.post("/me/auth-tokens", custom_headers, req.model_dump())
+
+            if not auth_tokens_result:
+                logger.error("Login failed: Received empty response from auth-tokens endpoint")
+                return False
+
+            auth_tokens_resp = AuthTokenResponse.model_validate(auth_tokens_result)
+
+            # Handle 2FA
+            if auth_tokens_resp.is2FARequired:
+                for attempt in range(3):
+                    code = input(f"Attempt {attempt + 1}/3: Please enter the 2FA code: ")
+                    create_session_req = CreateSessionRequest(
+                        type="native", authToken=auth_tokens_resp.authToken, otpCode=code
+                    )
+                    try:
+                        session_result = self.client.post("/me/sessions", custom_headers,
+                                                          create_session_req.model_dump())
+                        if session_result:
+                            break
+                    except RequestException:
+                        logger.warning("Invalid 2FA code, please try again.")
+                        if attempt == 2:
+                            logger.error("Failed to create session after 3 incorrect 2FA attempts.")
+                            return False
+            else:
+                create_session_req = CreateSessionRequest(type="native", authToken=auth_tokens_resp.authToken,
+                                                          otpCode=None)
+                session_result = self.client.post("/me/sessions", custom_headers, create_session_req.model_dump())
+
+            create_session_resp = CreateSessionResponse.model_validate(session_result)
 
-        resp = LoginResponse.model_validate(result)
-        self._access_token = resp.accessToken
-        self._refresh_token = resp.refreshToken
-        self._user_id = self.parse_user_id()
+            self._access_token = create_session_resp.accessToken
+            self._refresh_token = create_session_resp.refreshToken
+            self._user_id = self.parse_user_id()
 
-    def refresh_token(self):
+            # Fetch profile to get organization ID
+            profile_result = self.client.get("/me/profile", self.get_custom_headers())
+            if not profile_result:
+                logger.error("Failed to fetch user profile data.")
+                return False
+
+            profile_resp = ProfileResponse.model_validate(profile_result)
+            self._organization_id = profile_resp.organization.id
+
+            return True
+        except (RequestException, ValueError, KeyError) as e:
+            logger.error(f"Login failed due to exception: {e}")
+            return False
+
+    def refresh_token(self) -> bool:
         """
-        Refreshes a user's token using a refresh token.
+        Refreshes the access token. Returns True on success, False otherwise.
         """
-        custom_headers = {
-            CLIENT_ID_HEADER: self._client_id
-        }
-        result = self.client.patch("/me/sessions", custom_headers, {"refreshToken": self._refresh_token})
+        try:
+            custom_headers = {CLIENT_ID_HEADER: self._client_id}
+            result = self.client.patch("/me/sessions", custom_headers, {"refreshToken": self._refresh_token})
+
+            if not result:
+                logger.error("Failed to refresh token: Empty response received")
+                return False
 
-        resp = LoginResponse.model_validate(result)
-        self._access_token = resp.accessToken
-        self._refresh_token = resp.refreshToken
+            resp = CreateSessionResponse.model_validate(result)
+            self._access_token = resp.accessToken
+            self._refresh_token = resp.refreshToken
+
+            return True
+        except (RequestException, ValueError) as e:
+            logger.error(f"Token refresh failed: {e}")
+            return False
+
+    def create_org_api_key(self, request: CreateAPIKeyRequest) -> Optional[str]:
+        """
+        Creates a new API key for the current user.
+        """
+        try:
+            result = self.client.post(f"/organizations/{self.get_organization_id()}/api-keys",
+                                      self.get_custom_headers(), request.model_dump())
+
+            return CreateAPIKeyResponse.model_validate(result).key if result else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to create API key: {e}")
+            return None
+
+    def get_org_api_keys(self) -> Optional[GetAPIKeysResponse]:
+        """
+        Fetches all API keys for the current user.
+        """
+        try:
+            result = self.client.get(f"/organizations/{self.get_organization_id()}/api-keys",
+                                     self.get_custom_headers())
+
+            return GetAPIKeysResponse.model_validate(result) if result else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to retrieve organization API keys: {e}")
+            return None
 
     def parse_user_id(self) -> str:
         """
@@ -91,6 +173,12 @@ class IAMClient:
         """
         return self._client_id
 
+    def get_organization_id(self) -> str:
+        """
+        Gets the current organization ID.
+        """
+        return self._organization_id
+
     def get_custom_headers(self) -> dict:
         """
         Gets the custom headers for the IAM client.

gmicloud/_internal/_client/_task_client.py

@@ -1,9 +1,14 @@
+import logging
+from requests.exceptions import RequestException
+
 from ._http_client import HTTPClient
 from ._decorator import handle_refresh_token
 from ._iam_client import IAMClient
 from .._config import TASK_SERVICE_BASE_URL
 from .._models import *
 
+logger = logging.getLogger(__name__)
+
 
 class TaskClient:
     """
@@ -21,17 +26,19 @@ class TaskClient:
         self.iam_client = iam_client
 
     @handle_refresh_token
-    def get_task(self, task_id: str) -> Task:
+    def get_task(self, task_id: str) -> Optional[Task]:
         """
         Retrieves a task from the task service using the given task ID.
 
         :param task_id: The ID of the task to be retrieved.
-        :return: An instance of Task containing the details of the retrieved task.
-        :rtype: Task
+        :return: An instance of Task containing the details of the retrieved task, or None if an error occurs.
         """
-        result = self.client.get("/get_task", self.iam_client.get_custom_headers(), {"task_id": task_id})
-
-        return Task.model_validate(result)
+        try:
+            response = self.client.get("/get_task", self.iam_client.get_custom_headers(), {"task_id": task_id})
+            return Task.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to retrieve task {task_id}: {e}")
+            return None
 
     @handle_refresh_token
     def get_all_tasks(self) -> GetAllTasksResponse:
@@ -39,70 +46,108 @@ class TaskClient:
         Retrieves all tasks from the task service.
 
         :return: An instance of GetAllTasksResponse containing the retrieved tasks.
-        :rtype: GetAllTasksResponse
         """
-        result = self.client.get("/get_tasks", self.iam_client.get_custom_headers())
-        if not result:
+        try:
+            response = self.client.get("/get_tasks", self.iam_client.get_custom_headers())
+            if not response:
+                logger.error("Empty response from /get_tasks")
+                return GetAllTasksResponse(tasks=[])
+            return GetAllTasksResponse.model_validate(response)
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to retrieve all tasks: {e}")
             return GetAllTasksResponse(tasks=[])
 
-        return GetAllTasksResponse.model_validate(result)
-
     @handle_refresh_token
-    def create_task(self, task: Task) -> CreateTaskResponse:
+    def create_task(self, task: Task) -> Optional[CreateTaskResponse]:
         """
         Creates a new task using the provided task object.
 
         :param task: The Task object containing the details of the task to be created.
+        :return: The response object containing created task details, or None if an error occurs.
         """
-        result = self.client.post("/create_task", self.iam_client.get_custom_headers(), task.model_dump())
-
-        return CreateTaskResponse.model_validate(result)
+        try:
+            response = self.client.post("/create_task", self.iam_client.get_custom_headers(), task.model_dump())
+            return CreateTaskResponse.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to create task: {e}")
+            return None
 
     @handle_refresh_token
-    def update_task_schedule(self, task: Task):
+    def update_task_schedule(self, task: Task) -> bool:
         """
         Updates the schedule of an existing task.
 
         :param task: The Task object containing the updated task details.
+        :return: True if update is successful, False otherwise.
         """
-        self.client.put("/update_schedule", self.iam_client.get_custom_headers(), task.model_dump())
+        try:
+            response = self.client.put("/update_schedule", self.iam_client.get_custom_headers(), task.model_dump())
+            return response is not None
+        except RequestException as e:
+            logger.error(f"Failed to update schedule for task {task.task_id}: {e}")
+            return False
 
     @handle_refresh_token
-    def start_task(self, task_id: str):
+    def start_task(self, task_id: str) -> bool:
         """
         Starts a task using the given task ID.
 
         :param task_id: The ID of the task to be started.
+        :return: True if start is successful, False otherwise.
         """
-        self.client.post("/start_task", self.iam_client.get_custom_headers(), {"task_id": task_id})
+        try:
+            response = self.client.post("/start_task", self.iam_client.get_custom_headers(), {"task_id": task_id})
+            return response is not None
+        except RequestException as e:
+            logger.error(f"Failed to start task {task_id}: {e}")
+            return False
 
     @handle_refresh_token
-    def stop_task(self, task_id: str):
+    def stop_task(self, task_id: str) -> bool:
         """
         Stops a running task using the given task ID.
 
         :param task_id: The ID of the task to be stopped.
+        :return: True if stop is successful, False otherwise.
         """
-        self.client.post("/stop_task", self.iam_client.get_custom_headers(), {"task_id": task_id})
+        try:
+            response = self.client.post("/stop_task", self.iam_client.get_custom_headers(), {"task_id": task_id})
+            return response is not None
+        except RequestException as e:
+            logger.error(f"Failed to stop task {task_id}: {e}")
+            return False
 
     @handle_refresh_token
-    def get_usage_data(self, start_timestamp: str, end_timestamp: str) -> GetUsageDataResponse:
+    def get_usage_data(self, start_timestamp: str, end_timestamp: str) -> Optional[GetUsageDataResponse]:
         """
         Retrieves the usage data of a task using the given task ID.
 
         :param start_timestamp: The start timestamp of the usage data.
         :param end_timestamp: The end timestamp of the usage data.
-        """
-        result = self.client.get("/get_usage_data", self.iam_client.get_custom_headers(),
-                                 {"start_timestamp": start_timestamp, "end_timestamp": end_timestamp})
-
-        return result
+        :return: An instance of GetUsageDataResponse, or None if an error occurs.
+        """
+        try:
+            response = self.client.get(
+                "/get_usage_data",
+                self.iam_client.get_custom_headers(),
+                {"start_timestamp": start_timestamp, "end_timestamp": end_timestamp}
+            )
+            return GetUsageDataResponse.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to retrieve usage data from {start_timestamp} to {end_timestamp}: {e}")
+            return None
 
     @handle_refresh_token
-    def archive_task(self, task_id: str):
+    def archive_task(self, task_id: str) -> bool:
         """
         Archives a task using the given task ID.
 
         :param task_id: The ID of the task to be archived.
-        """
-        self.client.post("/archive_task", self.iam_client.get_custom_headers(), {"task_id": task_id})
+        :return: True if archiving is successful, False otherwise.
+        """
+        try:
+            response = self.client.post("/archive_task", self.iam_client.get_custom_headers(), {"task_id": task_id})
+            return response is not None
+        except RequestException as e:
+            logger.error(f"Failed to archive task {task_id}: {e}")
+            return False

gmicloud/_internal/_enums.py

@@ -23,3 +23,11 @@ class TaskEndpointStatus(str, Enum):
     READY = "ready"
     UNREADY = "unready"
     NEW = "new"
+
+class TaskStatus(str, Enum):
+    IDLE = "idle"
+    STARTING = "starting"
+    IN_QUEUE = "in-queue"
+    RUNNING = "running"
+    NEEDSTOP = "needstop"
+    ARCHIVED = "archived"