gmicloud 0.1.0__py3-none-any.whl

examples/example.py

@@ -0,0 +1,145 @@
+import os
+import time
+from datetime import datetime
+
+from openai import OpenAI
+
+from gmicloud import *
+
+
+def create_artifact_with_file(client: Client) -> str:
+    artifact_manager = client.artifact_manager
+
+    # Create an artifact with a file
+    artifact_id = artifact_manager.create_artifact_with_file(
+        artifact_name="Llama3.1 8B",
+        artifact_file_path="./files/Llama-3.1-8B-Instruct.zip",
+        description="This is a test artifact",
+        tags=['example', 'test']
+    )
+
+    return artifact_id
+
+
+def create_artifact_from_template(client: Client) -> str:
+    artifact_manager = client.artifact_manager
+
+    # Get all artifact templates
+    templates = artifact_manager.get_artifact_templates()
+    print(templates)
+    for template in templates:
+        if template.artifact_name == "Llama3.1 8B":
+            # Create an artifact from a template
+            artifact_id = artifact_manager.create_artifact_from_template(
+                artifact_template_id=template.artifact_template_id,
+            )
+
+            return artifact_id
+
+    return ""
+
+
+def create_task_and_start(client: Client, artifact_id: str) -> str:
+    artifact_manager = client.artifact_manager
+    # Wait for the artifact to be ready
+    while True:
+        try:
+            artifact = artifact_manager.get_artifact(artifact_id)
+            print(f"Artifact status: {artifact.build_status}")
+            # Wait until the artifact is ready
+            if artifact.build_status == BuildStatus.SUCCESS:
+                break
+        except Exception as e:
+            raise e
+        # Wait for 2 seconds
+        time.sleep(2)
+    try:
+        task_manager = client.task_manager
+        # Create a task
+        task = task_manager.create_task(Task(
+            config=TaskConfig(
+                ray_task_config=RayTaskConfig(
+                    ray_version="latest-py311-gpu",
+                    file_path="serve",
+                    artifact_id=artifact_id,
+                    deployment_name="app",
+                    replica_resource=ReplicaResource(
+                        cpu=24,
+                        ram_gb=128,
+                        gpu=2,
+                    ),
+                ),
+                task_scheduling=TaskScheduling(
+                    scheduling_oneoff=OneOffScheduling(
+                        trigger_timestamp=int(datetime.now().timestamp()) + 60,
+                        min_replicas=1,
+                        max_replicas=10,
+                    )
+                ),
+            ),
+        ))
+
+        # Start the task
+        task_manager.start_task(task.task_id)
+    except Exception as e:
+        raise e
+
+    return task.task_id
+
+
+def call_chat_completion(client: Client, task_id: str):
+    task_manager = client.task_manager
+    # Wait for the task to be ready
+    while True:
+        try:
+            task = task_manager.get_task(task_id)
+            print(f"task status: {task.task_status}")
+            # Wait until the task is ready
+            if task.task_status == "ready":
+                break
+        except Exception as e:
+            print(e)
+            return
+        # Wait for 2 seconds
+        time.sleep(2)
+
+    if not task.info.endpoint or not task.info.endpoint.strip():
+        raise Exception("Task endpoint is not ready yet")
+
+    open_ai = OpenAI(
+        api_key=os.getenv("OPENAI_API_KEY", "YOUR_DEFAULT_API_KEY"),
+        base_url=os.getenv("OPENAI_API_BASE", task.info.endpoint)
+    )
+    # Make a chat completion request using the new OpenAI client.
+    completion = open_ai.chat.completions.create(
+        model="meta-llama/Llama-3.1-8B-Instruct",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user",
+             "content": f"Translate the sentences to Chinese"},
+        ],
+        max_tokens=200,
+        temperature=0.7
+    )
+
+    print(completion.choices[0].message.content)
+
+
+if __name__ == '__main__':
+    # Initialize the Client
+    cli = Client()
+
+    # print(cli.artifact_manager.get_all_artifacts())
+
+    # Create an artifact with a file
+    # artifact_id = create_artifact_with_file(cli)
+
+    # Create an artifact from a template
+    #artifact_id = create_artifact_from_template(cli)
+    artifact_id = "cba6db2f-315a-4765-9e94-1e692f7fdb39"
+
+    # Create a task and start it
+    task_id = create_task_and_start(cli, artifact_id)
+
+    # Call chat completion
+    call_chat_completion(cli, task_id)

gmicloud/__init__.py

@@ -0,0 +1,41 @@
+from ._internal._models import (
+    Artifact,
+    ArtifactData,
+    ArtifactMetadata,
+    Task,
+    TaskOwner,
+    TaskConfig,
+    TaskInfo,
+    RayTaskConfig,
+    TaskScheduling,
+    ReplicaResource,
+    OneOffScheduling,
+    DailyScheduling,
+    DailyTrigger,
+    ArtifactTemplate
+)
+from ._internal._enums import (
+    BuildStatus,
+    TaskEndpointStatus
+)
+from .client import Client
+
+__all__ = [
+    "Client",
+    "Artifact",
+    "ArtifactData",
+    "ArtifactMetadata",
+    "Task",
+    "TaskOwner",
+    "TaskConfig",
+    "TaskInfo",
+    "RayTaskConfig",
+    "TaskScheduling",
+    "ReplicaResource",
+    "OneOffScheduling",
+    "DailyScheduling",
+    "DailyTrigger",
+    "ArtifactTemplate",
+    "BuildStatus",
+    "TaskEndpointStatus"
+]

gmicloud/_internal/_client/_artifact_client.py

@@ -0,0 +1,179 @@
+from typing import List
+
+from ._http_client import HTTPClient
+from ._iam_client import IAMClient
+from ._decorator import handle_refresh_token
+from .._models import *
+from .._config import ARTIFACT_SERVICE_BASE_URL
+from .._constants import ACCESS_TOKEN_HEADER, CLIENT_ID_HEADER
+
+
+class ArtifactClient:
+    """
+    Client for interacting with the Artifact Service API.
+
+    This client provides methods to perform CRUD operations on artifacts,
+    as well as generating signed URLs for uploading large files.
+    """
+
+    def __init__(self, iam_client: IAMClient):
+        """
+        Initializes the ArtifactClient with an HTTPClient configured
+        to communicate with the Artifact Service base URL.
+        """
+        self.client = HTTPClient(ARTIFACT_SERVICE_BASE_URL)
+        self.iam_client = iam_client
+
+    @handle_refresh_token
+    def get_artifact(self, artifact_id: str) -> Artifact:
+        """
+        Fetches an artifact by its ID.
+
+        :param artifact_id: The ID of the artifact to fetch.
+        :return: The Artifact object.
+        :rtype: Artifact
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        result = self.client.get(f"/get_artifact", custom_headers, {"artifact_id": artifact_id})
+
+        return Artifact.model_validate(result)
+
+    @handle_refresh_token
+    def get_all_artifacts(self, user_id: str) -> List[Artifact]:
+        """
+        Fetches all artifacts for a given user ID.
+
+        :param user_id: The ID of the user whose artifacts are being fetched.
+        :return: A list of Artifact objects.
+        :rtype: List[Artifact]
+        """
+        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_all_artifacts", custom_headers, {"user_id": user_id})
+        if not result:
+            return []
+        return [Artifact.model_validate(item) for item in result]
+
+    @handle_refresh_token
+    def create_artifact(self, request: CreateArtifactRequest) -> 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
+        """
+        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_artifact", custom_headers, request.model_dump())
+
+        return CreateArtifactResponse.model_validate(result)
+
+    @handle_refresh_token
+    def create_artifact_from_template(self,
+                                      request: CreateArtifactFromTemplateRequest) -> CreateArtifactFromTemplateResponse:
+        """
+        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: CreateArtifactFromTemplateResponse
+        """
+        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_artifact_from_template", custom_headers,
+                                  request.model_dump())
+
+        return CreateArtifactFromTemplateResponse.model_validate(result)
+
+    @handle_refresh_token
+    def rebuild_artifact(self, artifact_id: str) -> 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
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        result = self.client.post("/rebuild_artifact", custom_headers, {"artifact_id": artifact_id})
+
+        return CreateArtifactResponse.model_validate(result)
+
+    @handle_refresh_token
+    def delete_artifact(self, artifact_id: str) -> 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
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        result = self.client.delete("/delete_artifact", custom_headers, {"artifact_id": artifact_id})
+
+        return DeleteArtifactResponse.model_validate(result)
+
+    @handle_refresh_token
+    def get_bigfile_upload_url(self, request: GetBigFileUploadUrlRequest) -> 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
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        result = self.client.post("/get_bigfile_upload_url", custom_headers, request.model_dump())
+
+        return GetBigFileUploadUrlResponse.model_validate(result)
+
+    @handle_refresh_token
+    def delete_bigfile(self, request: DeleteBigfileRequest) -> 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
+        """
+        custom_headers = {
+            ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
+            CLIENT_ID_HEADER: self.iam_client.get_client_id()
+        }
+        result = self.client.delete("/delete_bigfile", custom_headers, request.dict())
+
+        return DeleteBigfileResponse.model_validate(result)
+
+    @handle_refresh_token
+    def get_artifact_templates(self) -> GetArtifactTemplatesResponse:
+        """
+        Fetches all artifact templates.
+
+        :return: A list of ArtifactTemplate objects.
+        :rtype: List[ArtifactTemplate]
+        """
+        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_artifact_templates", custom_headers)
+        return GetArtifactTemplatesResponse.model_validate(result)

gmicloud/_internal/_client/_decorator.py

@@ -0,0 +1,22 @@
+from functools import wraps
+
+from .._exceptions import UnauthorizedError
+
+
+def handle_refresh_token(method):
+    """
+    Decorator to handle automatic token refresh on 401 Unauthorized errors.
+    """
+
+    @wraps(method)
+    def wrapper(self, *args, **kwargs):
+        try:
+            # First attempt to call the original method
+            return method(self, *args, **kwargs)
+        except UnauthorizedError:  # Assume ArtifactClient raises this for 401 errors
+            # Refresh the token using the IAMClient
+            self.iam_client.refresh_token()
+            # Retry the original method
+            return method(self, *args, **kwargs)
+
+    return wrapper

gmicloud/_internal/_client/_file_upload_client.py

@@ -0,0 +1,115 @@
+import os
+import requests
+
+from .._exceptions import UploadFileError
+
+
+class FileUploadClient:
+    CHUNK_SIZE = 10 * 1024 * 1024  # 10MB Default Chunk Size
+
+    """
+    A file upload client supporting small files and resumable uploads (chunked uploads).
+    """
+
+    @staticmethod
+    def upload_small_file(upload_url: str, file_path: str,
+                          content_type: str = "application/zip"):
+        """
+        Uploads a small file directly to a signed Google Storage upload URL.
+
+        :param upload_url: Signed upload URL for small files.
+        :param file_path: The local path to the file to upload.
+        :param content_type: MIME type of the file.
+        """
+        try:
+            with open(file_path, "rb") as file:
+                file_data = file.read()
+
+            headers = {"Content-Type": content_type}
+            response = requests.put(upload_url, headers=headers, data=file_data)
+
+            if response.status_code not in [200, 201]:
+                raise UploadFileError(f"Failed to upload file, code:{response.status_code} ,message: {response.text}")
+
+        except requests.exceptions.RequestException as e:
+            raise UploadFileError(f"Failed to upload file: {str(e)}")
+
+    @staticmethod
+    def upload_large_file(upload_url: str, file_path: str, chunk_size: int = CHUNK_SIZE):
+        """
+        Performs resumable (chunked) file uploads to a signed Google Storage URL.
+
+        :param upload_url: Signed resumable upload URL.
+        :param file_path: The local path to the file to upload.
+        :param chunk_size: Chunk size in bytes (default: 10MB).
+        """
+        try:
+            file_size = os.path.getsize(file_path)
+            print(f"File Size: {file_size} bytes")
+
+            start_byte = 0
+            uploaded_range = FileUploadClient._check_file_status(upload_url, file_size)
+            if uploaded_range:
+                start_byte = int(uploaded_range.split("-")[1]) + 1
+                print(f"Resuming upload from {start_byte} bytes")
+
+            with open(file_path, "rb") as file:
+                while start_byte < file_size:
+                    # Calculate end byte and adjust chunk to not exceed file size
+                    end_byte = min(start_byte + chunk_size - 1, file_size - 1)
+
+                    # Seek to the current position in the file and read the chunk
+                    file.seek(start_byte)
+                    chunk_data = file.read(chunk_size)
+
+                    # Set the Content-Range and headers
+                    content_range = f"bytes {start_byte}-{end_byte}/{file_size}"
+                    headers = {
+                        "Content-Length": str(len(chunk_data)),
+                        "Content-Range": content_range
+                    }
+
+                    # Upload the chunk
+                    resp = requests.put(upload_url, headers=headers, data=chunk_data)
+                    # Ensure upload is successful for this chunk
+                    if resp.status_code not in (200, 201, 308):
+                        raise UploadFileError(
+                            f"Failed to upload file, code:{resp.status_code} ,message: {resp.text}")
+
+                    start_byte = end_byte + 1
+                    print(f"Uploaded {end_byte + 1}/{file_size} bytes")
+
+                print("Upload completed successfully.")
+        except Exception as e:
+            raise UploadFileError(f"Failed to upload file: {str(e)}")
+
+    @staticmethod
+    def _check_file_status(upload_url: str, file_size: int) -> str:
+        """
+        Check the status of a resumable upload.
+
+        :param upload_url: The resumable upload URL.
+        :param file_size: Total file size in bytes.
+        :return: The status of the upload (e.g., 'bytes=0-10485759') or None if no partial upload.
+        """
+        headers = {
+            "Content-Length": "0",  # No payload for status check
+            "Content-Range": f"bytes */{file_size}"  # Asking server where the upload left off
+        }
+
+        try:
+            resp = requests.put(upload_url, headers=headers)
+
+            # If upload is incomplete (HTTP 308: Resume Incomplete), retrieve the "Range" header
+            if resp.status_code == 308:
+                range_header = resp.headers.get("Range")
+                if range_header:
+                    print(f"Server reports partial upload range: {range_header}")
+                return range_header
+
+            if resp.status_code in (200, 201):
+                return None
+
+            resp.raise_for_status()
+        except requests.RequestException as e:
+            raise UploadFileError(f"Failed to check file status: {str(e)}") from e

gmicloud/_internal/_client/_http_client.py

@@ -0,0 +1,150 @@
+import requests
+from .._exceptions import APIError
+from .._exceptions import UnauthorizedError
+from .._constants import *
+from .._config import *
+
+
+class HTTPClient:
+    """
+    A simple HTTP API client for interacting with REST APIs.
+    """
+
+    def __init__(self, base_url):
+        """
+        Initialize the HTTP client.
+
+        :param base_url: The base URL of the REST API (e.g., https://api.example.com)
+        """
+        self.base_url = base_url.rstrip('/')
+
+    def _prepare_url(self, endpoint):
+        """
+        Helper method to prepare the full URL.
+
+        :param endpoint: The API endpoint to append to the base URL.
+        :return: The full API URL as a string.
+        """
+        return f"{self.base_url}{endpoint}"
+
+    def _send_request(self, method, endpoint, custom_headers=None, data=None, params=None):
+        """
+        Internal method for sending HTTP requests.
+
+        :param method: The HTTP method (e.g., 'GET', 'POST', 'PUT', 'PATCH', 'DELETE').
+        :param endpoint: The API endpoint.
+        :param custom_headers: The request headers (optional).
+        :param data: The request payload for POST/PUT/PATCH requests (optional).
+        :param params: The query parameters for GET/DELETE requests (optional).
+        :return: The JSON response parsed as a Python dictionary.
+        :raises APIError: If the request fails or the response is invalid.
+        """
+        print("data=", data)
+        url = self._prepare_url(endpoint)
+        headers = {
+            ACCEPT_HEADER: JSON_CONTENT_TYPE,
+            CONTENT_TYPE_HEADER: JSON_CONTENT_TYPE,
+        }
+
+        # Add custom headers if provided
+        if custom_headers:
+            headers.update(custom_headers)
+
+        response = None
+        try:
+            # if method == HTTP_METHOD_POST:
+            #     response = requests.post(url, json=data, headers=headers)
+            # elif method == HTTP_METHOD_GET:
+            #     response = requests.get(url, params=params, headers=headers)
+            # elif method == HTTP_METHOD_PATCH:
+            #     response = requests.patch(url, data=data, headers=headers)
+            # elif method == HTTP_METHOD_DELETE:
+            #     response = requests.delete(url, params=params, headers=headers)
+            # else:
+            #     raise APIError(f"Unsupported HTTP method: {method}")
+            response = requests.request(method, url, params=params, json=data, headers=headers)
+            # response = method_map[method](url, json=data if method != HTTP_METHOD_GET else None,
+            #                               params=params, headers=headers)
+
+            print("=============", response.text)
+            if response.status_code == 401:
+                raise UnauthorizedError("Access token expired or invalid.")
+            elif response.status_code != 200 and response.status_code != 201:
+                if url.find("ie/artifact") != -1 or url.find("ie/task") != -1:
+                    error_message = response.json().get('error', 'Unknown error')
+                else:
+                    error_message = response.json().get('message', 'Unknown error')
+                raise APIError(f"HTTP Request failed: {error_message}")
+
+            # Raise for HTTP errors
+            response.raise_for_status()
+
+        except requests.exceptions.RequestException as e:
+            raise APIError(f"HTTP Request failed: {str(e)}")
+        except ValueError as e:
+            # Fallback if response JSON is invalid
+            raise APIError(f"Failed to parse JSON response: {response.text}")
+
+        if response.headers.get(CONTENT_TYPE_HEADER).find(JSON_CONTENT_TYPE) != -1:
+            return response.json()
+        elif response.headers.get(CONTENT_TYPE_HEADER).find(TEXT_CONTENT_TYPE) != -1:
+            raise APIError(f"Got text response: {response.text}")
+        else:
+            raise APIError(f"Unsupported content type: {response.headers.get(CONTENT_TYPE_HEADER)}")
+
+    def post(self, endpoint, custom_headers=None, data=None):
+        """
+        Send a POST request to the given API endpoint.
+
+        :param endpoint: The API endpoint.
+        :param custom_headers: The request headers (optional).
+        :param data: The request payload as a dictionary.
+        :return: The JSON response parsed as a Python dictionary.
+        """
+        return self._send_request(method=HTTP_METHOD_POST, endpoint=endpoint, custom_headers=custom_headers, data=data)
+
+    def get(self, endpoint, custom_headers=None, params=None):
+        """
+        Send a GET request to the given API endpoint.
+
+        :param endpoint: The API endpoint.
+        :param custom_headers: The request headers (optional).
+        :param params: Query parameters as a dictionary (optional).
+        :return: The JSON response parsed as a Python dictionary.
+        """
+        return self._send_request(method=HTTP_METHOD_GET, endpoint=endpoint, custom_headers=custom_headers,
+                                  params=params)
+
+    def put(self, endpoint, custom_headers=None, data=None):
+        """
+        Send a PUT request to the given API endpoint.
+
+        :param endpoint: The API endpoint.
+        :param custom_headers: The request headers (optional).
+        :param data: The request payload as a dictionary.
+        :return: The JSON response parsed as a Python dictionary.
+        """
+        return self._send_request(method=HTTP_METHOD_PUT, endpoint=endpoint, custom_headers=custom_headers, data=data)
+
+    def patch(self, endpoint, custom_headers=None, data=None):
+        """
+        Send a PATCH request to the given API endpoint.
+
+        :param endpoint: The API endpoint.
+        :param custom_headers: The request headers (optional).
+        :param data: The request payload as a dictionary.
+        :return: The JSON response parsed as a Python dictionary.
+        """
+        return self._send_request(method=HTTP_METHOD_PATCH, endpoint=endpoint, custom_headers=custom_headers, data=data)
+
+    def delete(self, endpoint, custom_headers=None, params=None):
+        """
+        Send a DELETE request to the given API endpoint.
+
+        :param endpoint: The API endpoint.
+        :param custom_headers: The request headers (optional).
+        :param params: Query parameters as a dictionary (optional).
+        :return: The JSON response parsed as a Python dictionary.
+        """
+        return self._send_request(method=HTTP_METHOD_DELETE, endpoint=endpoint, custom_headers=custom_headers,
+                                  params=params)