gmicloud 0.1.0__py3-none-any.whl

gmicloud/_internal/_client/_iam_client.py

@@ -0,0 +1,92 @@
+import jwt
+
+from ._http_client import HTTPClient
+from .._config import IAM_SERVICE_BASE_URL
+from .._models import *
+from .._constants import CLIENT_ID_HEADER
+
+
+class IAMClient:
+    """
+    Client for interacting with the IAM Service API.
+    """
+
+    def __init__(self, client_id: str, email: str, password: str):
+        """
+        Initialize IAMClient with client credentials and an IAMClient instance.
+
+        :param client_id: Client ID for login.
+        :param email: Email for login.
+        :param password: Password for login.
+        """
+        self._client_id = client_id
+        self._email = email
+        self._password = password
+        self._access_token = ""
+        self._refresh_token = ""
+        self._user_id = ""
+        self.client = HTTPClient(IAM_SERVICE_BASE_URL)
+
+    def login(self):
+        """
+        Logs in a user with the given username and password.
+        """
+        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())
+
+        resp = LoginResponse.model_validate(result)
+        self._access_token = resp.accessToken
+        self._refresh_token = resp.refreshToken
+        self._user_id = self.parse_user_id()
+
+    def refresh_token(self):
+        """
+        Refreshes a user's token using a refresh token.
+        """
+        custom_headers = {
+            CLIENT_ID_HEADER: self._client_id
+        }
+        result = self.client.patch("/me/sessions", custom_headers, {"refreshToken": self.refresh_token})
+
+        resp = LoginResponse.model_validate(result)
+        self._access_token = resp.accessToken
+        self._refresh_token = resp.refreshToken
+
+    def parse_user_id(self) -> str:
+        """
+        Parses the current access token and returns the user ID.
+        """
+        return self.parse_token()["userId"]
+
+    def parse_token(self) -> dict:
+        """
+        Parses the current access token and returns the payload as a dictionary.
+        """
+        return jwt.decode(self._access_token, options={"verify_signature": False})
+
+    def get_access_token(self) -> str:
+        """
+        Gets the current access token.
+        """
+        return self._access_token
+
+    def get_refresh_token(self) -> str:
+        """
+        Gets the current refresh token.
+        """
+        return self._refresh_token
+
+    def get_user_id(self) -> str:
+        """
+        Gets the current user ID.
+        """
+        return self._user_id
+
+    def get_client_id(self) -> str:
+        """
+        Gets the current client ID.
+        """
+        return self._client_id

gmicloud/_internal/_client/_task_client.py

@@ -0,0 +1,142 @@
+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 *
+from .._constants import ACCESS_TOKEN_HEADER, CLIENT_ID_HEADER
+
+
+class TaskClient:
+    """
+    A client for interacting with the task service API.
+
+    This client provides methods to retrieve, create, update, and stop tasks
+    through HTTP calls to the task service.
+    """
+
+    def __init__(self, iam_client: IAMClient):
+        """
+        Initializes the TaskClient with the given base URL for the task service.
+        """
+        self.client = HTTPClient(TASK_SERVICE_BASE_URL)
+        self.iam_client = iam_client
+
+    @handle_refresh_token
+    def get_task(self, task_id: str) -> 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
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        result = self.client.get("/get_task", custom_headers, {"task_id": task_id})
+
+        return Task.model_validate(result)
+
+    @handle_refresh_token
+    def get_all_tasks(self, user_id: str) -> GetAllTasksResponse:
+        """
+        Retrieves all tasks from the task service.
+
+        :return: An instance of GetAllTasksResponse containing the retrieved tasks.
+        :rtype: GetAllTasksResponse
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        result = self.client.get("/get_tasks", custom_headers, {"user_id": user_id})
+        if not result:
+            return GetAllTasksResponse(tasks=[])
+
+        return GetAllTasksResponse.model_validate(result)
+
+    @handle_refresh_token
+    def create_task(self, task: Task) -> CreateTaskResponse:
+        """
+        Creates a new task using the provided task object.
+
+        :param task: The Task object containing the details of the task to be created.
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+
+        result = self.client.post("/create_task", custom_headers, task.model_dump())
+
+        return CreateTaskResponse.model_validate(result)
+
+    @handle_refresh_token
+    def update_task_schedule(self, task: Task):
+        """
+        Updates the schedule of an existing task.
+
+        :param task: The Task object containing the updated task details.
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        self.client.put("/update_schedule", custom_headers, task.model_dump())
+
+    @handle_refresh_token
+    def start_task(self, task_id: str):
+        """
+        Starts a task using the given task ID.
+
+        :param task_id: The ID of the task to be started.
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        self.client.post("/start_task", custom_headers, {"task_id": task_id})
+
+    @handle_refresh_token
+    def stop_task(self, task_id: str):
+        """
+        Stops a running task using the given task ID.
+
+        :param task_id: The ID of the task to be stopped.
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        self.client.post("/stop_task", custom_headers, {"task_id": task_id})
+
+    @handle_refresh_token
+    def get_usage_data(self, start_timestamp: str, end_timestamp: str) -> 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.
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        result = self.client.get("/get_usage_data", custom_headers,
+                                 {"start_timestamp": start_timestamp, "end_timestamp": end_timestamp})
+
+        return result
+
+    @handle_refresh_token
+    def archive_task(self, task_id: str):
+        """
+        Archives a task using the given task ID.
+
+        :param task_id: The ID of the task to be archived.
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        self.client.post("/archive_task", custom_headers, {"task_id": task_id})

gmicloud/_internal/_config.py

@@ -0,0 +1,3 @@
+ARTIFACT_SERVICE_BASE_URL = "https://ce-tot.gmicloud-dev.com/api/v1/ie/artifact"
+TASK_SERVICE_BASE_URL = "https://ce-tot.gmicloud-dev.com/api/v1/ie/task"
+IAM_SERVICE_BASE_URL = "https://ce-tot.gmicloud-dev.com/api/v1"

gmicloud/_internal/_constants.py

@@ -0,0 +1,13 @@
+ACCEPT_HEADER = 'Accept'
+CONTENT_TYPE_HEADER = 'Content-Type'
+CLIENT_ID_HEADER = 'CE-ClientId'
+ACCESS_TOKEN_HEADER = 'CE-AccessToken'
+
+HTTP_METHOD_POST = 'POST'
+HTTP_METHOD_GET = 'GET'
+HTTP_METHOD_PATCH = 'PATCH'
+HTTP_METHOD_DELETE = 'DELETE'
+HTTP_METHOD_PUT = 'PUT'
+
+JSON_CONTENT_TYPE = 'application/json'
+TEXT_CONTENT_TYPE = 'text/html'

gmicloud/_internal/_enums.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class BuildStatus(str, Enum):
+    INIT = "INIT"
+    CREATED = "CREATED"
+    BUILDING = "BUILDING"
+    SUCCESS = "SUCCESS"
+    FAILURE = "FAILURE"
+    TIMEOUT = "TIMEOUT"
+    CANCELLED = "CANCELLED"
+    WORKING = "WORKING"
+    QUEUED = "QUEUED"
+
+
+class TaskEndpointStatus(str, Enum):
+    PENDING = "pending"
+    DEPLOYING = "deploying"
+    SCALING = "scaling"
+    RUNNING = "running"
+    ARCHIVED = "archived"
+    READY = "ready"
+    UNREADY = "unready"

gmicloud/_internal/_exceptions.py

@@ -0,0 +1,19 @@
+class APIError(Exception):
+    """
+    Generic exception for API-related errors.
+    """
+    pass
+
+
+class UploadFileError(Exception):
+    """
+    Exception for file upload errors.
+    """
+    pass
+
+
+class UnauthorizedError(Exception):
+    """
+    Exception for unauthorized access errors.
+    """
+    pass

gmicloud/_internal/_manager/_artifact_manager.py

@@ -0,0 +1,303 @@
+import os
+from typing import List
+import mimetypes
+
+from .._client._iam_client import IAMClient
+from .._client._artifact_client import ArtifactClient
+from .._client._file_upload_client import FileUploadClient
+from .._models import *
+
+
+class ArtifactManager:
+    """
+    Artifact Manager handles creation, retrieval, and file upload associated with artifacts.
+    """
+
+    def __init__(self, iam_client: IAMClient):
+        """
+        Initialize the ArtifactManager instance with the user ID and access token.
+
+        :param iam_client: The IAMClient instance to use for authentication.
+        :raises ValueError: If the `user_id` is None or an empty string.
+        """
+        self.iam_client = iam_client
+        self.artifact_client = ArtifactClient(iam_client)
+
+    def get_artifact(self, artifact_id: str) -> Artifact:
+        """
+        Retrieve an artifact by its ID.
+
+        :param artifact_id: The ID of the artifact to retrieve.
+        :return: The Artifact object associated with the ID.
+        :rtype: Artifact
+        :raises ValueError: If `artifact_id` is None or empty.
+        """
+        self._validate_artifact_id(artifact_id)
+
+        return self.artifact_client.get_artifact(artifact_id)
+
+    def get_all_artifacts(self) -> List[Artifact]:
+        """
+        Retrieve all artifacts for a given user.
+
+        :return: A list of Artifact objects associated with the user.
+        :rtype: List[Artifact]
+        """
+        return self.artifact_client.get_all_artifacts(self.iam_client.get_user_id())
+
+    def create_artifact(
+            self,
+            artifact_name: str,
+            description: Optional[str] = "",
+            tags: Optional[List[str]] = None
+    ) -> CreateArtifactResponse:
+        """
+        Create a new artifact for a user.
+
+        :param artifact_name: The name of the artifact.
+        :param description: An optional description for the artifact.
+        :param tags: Optional tags associated with the artifact, as a comma-separated string.
+        :return: A `CreateArtifactResponse` object containing information about the created artifact.
+        :rtype: CreateArtifactResponse
+        """
+        if not artifact_name or not artifact_name.strip():
+            raise ValueError("Artifact name is required and cannot be empty.")
+
+        req = CreateArtifactRequest(user_id=self.iam_client.get_user_id(), artifact_name=artifact_name,
+                                    artifact_description=description,
+                                    artifact_tags=tags, )
+
+        return self.artifact_client.create_artifact(req)
+
+    def create_artifact_from_template(self, artifact_template_id: str) -> CreateArtifactFromTemplateResponse:
+        """
+        Create a new artifact for a user using a template.
+
+        :param artifact_template_id: The ID of the template to use for the artifact.
+        :return: A `CreateArtifactResponse` object containing information about the created artifact.
+        :rtype: CreateArtifactResponse
+        """
+        if not artifact_template_id or not artifact_template_id.strip():
+            raise ValueError("Artifact template ID is required and cannot be empty.")
+
+        req = CreateArtifactFromTemplateRequest(user_id=self.iam_client.get_user_id(),
+                                                artifact_template_id=artifact_template_id)
+
+        return self.artifact_client.create_artifact_from_template(req)
+
+    def rebuild_artifact(self, artifact_id: str) -> RebuildArtifactResponse:
+        """
+        Rebuild an existing artifact.
+
+        :param artifact_id: The ID of the artifact to rebuild.
+        :return: A `RebuildArtifactResponse` object containing information about the rebuilt artifact.
+        :rtype: RebuildArtifactResponse
+        :raises ValueError: If `artifact_id` is None or empty
+        """
+        self._validate_artifact_id(artifact_id)
+
+        return self.artifact_client.rebuild_artifact(artifact_id)
+
+    def delete_artifact(self, artifact_id: str) -> DeleteArtifactResponse:
+        """
+        Delete an existing artifact.
+
+        :param artifact_id: The ID of the artifact to delete.
+        :return: A `DeleteArtifactResponse` object containing information about the deleted artifact.
+        :rtype: DeleteArtifactResponse
+        :raises ValueError: If `artifact_id` is None or empty
+        """
+        self._validate_artifact_id(artifact_id)
+
+        return self.artifact_client.delete_artifact(artifact_id)
+
+    def upload_artifact_file(self, upload_link: str, artifact_file_path: str) -> None:
+        """
+        Upload a file associated with an artifact.
+
+        :param upload_link: The URL to upload the artifact file.
+        :param artifact_file_path: The path to the artifact file.
+        :raises ValueError: If `file_path` is None or empty.
+        :raises FileNotFoundError: If the provided `file_path` does not exist.
+        """
+        self._validate_artifact_file_path(artifact_file_path)
+        artifact_file_type = mimetypes.guess_type(artifact_file_path)[0]
+
+        FileUploadClient.upload_small_file(upload_link, artifact_file_path, artifact_file_type)
+
+    def create_artifact_with_file(
+            self,
+            artifact_name: str,
+            artifact_file_path: str,
+            description: Optional[str] = "",
+            tags: Optional[List[str]] = None
+    ) -> str:
+        """
+        Create a new artifact for a user and upload a file associated with the artifact.
+
+        :param artifact_name: The name of the artifact.
+        :param artifact_file_path: The path to the artifact file(Dockerfile+serve.py).
+        :param description: An optional description for the artifact.
+        :param tags: Optional tags associated with the artifact, as a comma-separated string.
+        :return: The `artifact_id` of the created artifact.
+        :rtype: str
+        :raises FileNotFoundError: If the provided `file_path` does not exist.
+        """
+        self._validate_artifact_file_path(artifact_file_path)
+
+        # Create the artifact
+        create_artifact_resp = self.create_artifact(artifact_name, description, tags)
+        artifact_id = create_artifact_resp.artifact_id
+
+        artifact_file_type = mimetypes.guess_type(artifact_file_path)[0]
+        FileUploadClient.upload_small_file(create_artifact_resp.upload_link, artifact_file_path, artifact_file_type)
+
+        return artifact_id
+
+    def get_bigfile_upload_url(self, artifact_id: str, model_file_path: str) -> str:
+        """
+        Generate a pre-signed URL for uploading a large file associated with an artifact.
+
+        :param artifact_id: The ID of the artifact for which the file is being uploaded.
+        :param model_file_path: The path to the model file.
+        :return: The pre-signed upload URL for the large file.
+        :rtype: str
+        :raises ValueError: If `artifact_id` is None or empty.
+        """
+        self._validate_artifact_id(artifact_id)
+        self._validate_file_path(model_file_path)
+
+        model_file_name = os.path.basename(model_file_path)
+        model_file_type = mimetypes.guess_type(model_file_path)[0]
+
+        req = GetBigFileUploadUrlRequest(artifact_id=artifact_id, file_name=model_file_name, file_type=model_file_type)
+
+        return self.artifact_client.get_bigfile_upload_url(req).upload_link
+
+    def delete_bigfile(self, artifact_id: str, file_name: str) -> str:
+        """
+        Delete a large file associated with an artifact.
+
+        :param artifact_id: The ID of the artifact for which the file is being deleted.
+        :param file_name: The name of the file being deleted.
+        """
+        self._validate_artifact_id(artifact_id)
+        self._validate_file_name(file_name)
+
+        return self.artifact_client.delete_bigfile(artifact_id, file_name).status
+
+    def upload_large_file(self, upload_link: str, file_path: str) -> None:
+        """
+        Upload a large file to the specified URL.
+
+        :param upload_link: The URL to upload the file.
+        :param file_path: The path to the file to upload.
+        :raises ValueError: If `file_path` is None or empty.
+        :raises ValueError: If `upload_link` is None or empty.
+        :raises FileNotFoundError: If the provided `file_path` does not exist.
+        """
+        self._validate_file_path(file_path)
+        self._validate_upload_url(upload_link)
+
+        FileUploadClient.upload_large_file(upload_link, file_path)
+
+    def create_artifact_with_model_files(
+            self,
+            artifact_name: str,
+            artifact_file_path: str,
+            model_file_paths: List[str],
+            description: Optional[str] = "",
+            tags: Optional[str] = None
+    ) -> str:
+        """
+        Create a new artifact for a user and upload model files associated with the artifact.
+
+        :param artifact_name: The name of the artifact.
+        :param artifact_file_path: The path to the artifact file(Dockerfile+serve.py).
+        :param model_file_paths: The paths to the model files.
+        :param description: An optional description for the artifact.
+        :param tags: Optional tags associated with the artifact, as a comma-separated string.
+        :return: The `artifact_id` of the created artifact.
+        :raises FileNotFoundError: If the provided `file_path` does not exist.
+        """
+        artifact_id = self.create_artifact_with_file(artifact_name, artifact_file_path, description, tags)
+
+        for model_file_path in model_file_paths:
+            self._validate_file_path(model_file_path)
+            bigfile_upload_url_resp = self.artifact_client.get_bigfile_upload_url(
+                GetBigFileUploadUrlRequest(artifact_id=artifact_id, model_file_path=model_file_path)
+            )
+            FileUploadClient.upload_large_file(bigfile_upload_url_resp.upload_link, model_file_path)
+
+        return artifact_id
+
+    def get_artifact_templates(self) -> List[ArtifactTemplate]:
+        """
+        Fetch all artifact templates.
+
+        :return: A list of ArtifactTemplate objects.
+        :rtype: List[ArtifactTemplate]
+        """
+        return self.artifact_client.get_artifact_templates().artifact_templates
+
+    @staticmethod
+    def _validate_file_name(file_name: str) -> None:
+        """
+        Validate the file name.
+
+        :param file_name: The file name to validate.
+        :raises ValueError: If `file_name` is None or empty.
+        """
+        if not file_name or not file_name.strip():
+            raise ValueError("File name is required and cannot be empty.")
+
+    @staticmethod
+    def _validate_artifact_id(artifact_id: str) -> None:
+        """
+        Validate the artifact ID.
+
+        :param artifact_id: The artifact ID to validate.
+        :raises ValueError: If `artifact_id` is None or empty.
+        """
+        if not artifact_id or not artifact_id.strip():
+            raise ValueError("Artifact ID is required and cannot be empty.")
+
+    @staticmethod
+    def _validate_artifact_file_path(artifact_file_path: str) -> None:
+        """
+        Validate the artifact file path.
+
+        :param artifact_file_path: The file path to validate.
+        :raises ValueError: If `file_path` is None or empty.
+        :raises FileNotFoundError: If the provided `file_path` does not exist.
+        """
+        ArtifactManager._validate_file_path(artifact_file_path)
+
+        file_type = mimetypes.guess_type(artifact_file_path)[0]
+        if file_type != "application/zip":
+            raise ValueError("File type must be application/zip.")
+
+    @staticmethod
+    def _validate_upload_url(upload_link: str) -> None:
+        """
+        Validate the upload URL.
+
+        :param upload_link: The upload URL to validate.
+        :raises ValueError: If `upload_link` is None or empty.
+        """
+        if not upload_link or not upload_link.strip():
+            raise ValueError("Upload link is required and cannot be empty.")
+
+    @staticmethod
+    def _validate_file_path(file_path: str) -> None:
+        """
+        Validate the file path.
+
+        :param file_path: The file path to validate.
+        :raises ValueError: If `file_path` is None or empty.
+        :raises FileNotFoundError: If the provided `file_path` does not exist.
+        """
+        if not file_path or not file_path.strip():
+            raise ValueError("File path is required and cannot be empty.")
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")