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

gmicloud/_internal/_enums.py

@@ -31,3 +31,8 @@ class TaskStatus(str, Enum):
     RUNNING = "running"
     NEEDSTOP = "needstop"
     ARCHIVED = "archived"
+
+class ModelParameterType(str, Enum):
+    NUMERIC = "numeric"
+    TEXT = "text"
+    BOOLEAN = "boolean"

gmicloud/_internal/_manager/_artifact_manager.py

@@ -1,4 +1,5 @@
 import os
+import time
 from typing import List
 import mimetypes
 
@@ -7,6 +8,9 @@ from .._client._artifact_client import ArtifactClient
 from .._client._file_upload_client import FileUploadClient
 from .._models import *
 
+import logging
+
+logger = logging.getLogger(__name__)
 
 class ArtifactManager:
     """
@@ -86,6 +90,41 @@ class ArtifactManager:
             raise ValueError("Failed to create artifact from template.")
 
         return resp.artifact_id
+    
+    def create_artifact_from_template_name(self, artifact_template_name: str) -> tuple[str, ReplicaResource]:
+        """
+        Create an artifact from a template.
+        :param artifact_template_name: The name of the template to use.
+        :return: A tuple containing the artifact ID and the recommended replica resources.
+        :rtype: tuple[str, ReplicaResource]
+        """
+
+        recommended_replica_resources = None
+        template_id = None
+        try:
+            templates = self.get_public_templates()
+        except Exception as e:
+            logger.error(f"Failed to get artifact templates, Error: {e}")
+        for template in templates:
+            if template.template_data and template.template_data.name == artifact_template_name:
+                resources_template = template.template_data.resources
+                recommended_replica_resources = ReplicaResource(
+                    cpu=resources_template.cpu,
+                    ram_gb=resources_template.memory,
+                    gpu=resources_template.gpu,
+                    gpu_name=resources_template.gpu_name,
+                )
+                template_id = template.template_id
+                break
+        if not template_id:
+            raise ValueError(f"Template with name {artifact_template_name} not found.")
+        try: 
+            artifact_id = self.create_artifact_from_template(template_id)
+            self.wait_for_artifact_ready(artifact_id)
+            return artifact_id, recommended_replica_resources
+        except Exception as e:
+            logger.error(f"Failed to create artifact from template, Error: {e}")
+            raise e
 
     def rebuild_artifact(self, artifact_id: str) -> RebuildArtifactResponse:
         """
@@ -240,7 +279,31 @@ class ArtifactManager:
             FileUploadClient.upload_large_file(bigfile_upload_url_resp.upload_link, model_file_path)
 
         return artifact_id
-
+    
+
+    def wait_for_artifact_ready(self, artifact_id: str, timeout_s: int = 900) -> None:
+        """
+        Wait for an artifact to be ready.
+
+        :param artifact_id: The ID of the artifact to wait for.
+        :param timeout_s: The timeout in seconds.
+        :return: None
+        """
+        start_time = time.time()
+        while True:
+            try:
+                artifact = self.get_artifact(artifact_id)
+                if artifact.build_status == BuildStatus.SUCCESS:
+                    return
+                elif artifact.build_status in [BuildStatus.FAILED, BuildStatus.TIMEOUT, BuildStatus.CANCELLED]:
+                    raise Exception(f"Artifact build failed, status: {artifact.build_status}")
+            except Exception as e:
+                logger.error(f"Failed to get artifact, Error: {e}")
+            if time.time() - start_time > timeout_s:
+                raise Exception(f"Artifact build takes more than {timeout_s // 60} minutes. Testing aborted.")
+            time.sleep(10)
+
+    
     def get_public_templates(self) -> List[ArtifactTemplate]:
         """
         Fetch all artifact templates.
@@ -249,6 +312,26 @@ class ArtifactManager:
         :rtype: List[ArtifactTemplate]
         """
         return self.artifact_client.get_public_templates()
+        
+
+    def list_public_template_names(self) -> list[str]:
+        """
+        List all public templates.
+
+        :return: A list of template names.
+        :rtype: list[str]
+        """
+        template_names = []
+        try: 
+            templates = self.get_public_templates()
+            for template in templates:
+                if template.template_data and template.template_data.name:
+                    template_names.append(template.template_data.name)
+            return template_names
+        except Exception as e:
+            logger.error(f"Failed to get artifact templates, Error: {e}")
+            return []
+
 
     @staticmethod
     def _validate_file_name(file_name: str) -> None:

gmicloud/_internal/_manager/_task_manager.py

@@ -4,6 +4,10 @@ from .._client._iam_client import IAMClient
 from .._client._task_client import TaskClient
 from .._models import *
 
+import time
+import logging
+
+logger = logging.getLogger(__name__)
 
 class TaskManager:
     """
@@ -132,6 +136,50 @@ class TaskManager:
         self._validate_not_empty(task_id, "Task ID")
 
         return self.task_client.start_task(task_id)
+    
+
+    def start_task_and_wait(self, task_id: str, timeout_s: int = 900) -> Task:
+        """
+        Start a task and wait for it to be ready.
+
+        :param task_id: The ID of the task to start.
+        :param timeout_s: The timeout in seconds.
+        :return: The task object.
+        :rtype: Task
+        """
+        # trigger start task
+        try:
+            self.start_task(task_id)
+            logger.info(f"Started task ID: {task_id}")
+        except Exception as e:
+            logger.error(f"Failed to start task, Error: {e}")
+            raise e
+        
+        start_time = time.time()
+        while True:
+            try:
+                task = self.get_task(task_id)
+                if task.task_status == TaskStatus.RUNNING:
+                    return task
+                elif task.task_status in [TaskStatus.NEEDSTOP, TaskStatus.ARCHIVED]:
+                    raise Exception(f"Unexpected task status after starting: {task.task_status}")
+                # Also check endpoint status. 
+                elif task.task_status == TaskStatus.RUNNING:
+                    if task.endpoint_info and task.endpoint_info.endpoint_status == TaskEndpointStatus.RUNNING:
+                        return task
+                    elif task.endpoint_info and task.endpoint_info.endpoint_status in [TaskEndpointStatus.UNKNOWN, TaskEndpointStatus.ARCHIVED]:
+                        raise Exception(f"Unexpected endpoint status after starting: {task.endpoint_info.endpoint_status}")
+                    else:
+                        logger.info(f"Pending endpoint starting. endpoint status: {task.endpoint_info.endpoint_status}")
+                else:
+                    logger.info(f"Pending task starting. Task status: {task.task_status}")
+
+            except Exception as e:
+                logger.error(f"Failed to get task, Error: {e}")
+            if time.time() - start_time > timeout_s:
+                raise Exception(f"Task creation takes more than {timeout_s // 60} minutes. Testing aborted.")
+            time.sleep(10)
+
 
     def stop_task(self, task_id: str) -> bool:
         """
@@ -143,6 +191,27 @@ class TaskManager:
         """
         self._validate_not_empty(task_id, "Task ID")
 
+        
+    def stop_task_and_wait(self, task_id: str, timeout_s: int = 900):
+        task_manager = self.task_manager
+        try:
+            self.task_manager.stop_task(task_id)
+            logger.info(f"Stopping task ID: {task_id}")
+        except Exception as e:
+            logger.error(f"Failed to stop task, Error: {e}")
+        task_manager = self.task_manager
+        start_time = time.time()
+        while True:
+            try:
+                task = self.get_task(task_id)
+                if task.task_status == TaskStatus.IDLE:
+                    break
+            except Exception as e:
+                logger.error(f"Failed to get task, Error: {e}")
+            if time.time() - start_time > timeout_s:
+                raise Exception(f"Task stopping takes more than {timeout_s // 60} minutes. Testing aborted.")
+            time.sleep(10)
+
         return self.task_client.stop_task(task_id)
 
     def get_usage_data(self, start_timestamp: str, end_timestamp: str) -> GetUsageDataResponse:

gmicloud/_internal/_models.py

@@ -1,8 +1,8 @@
-from typing import Optional, List
+from typing import Optional, List, Union
 from datetime import datetime
 
 from pydantic import BaseModel
-from gmicloud._internal._enums import BuildStatus, TaskStatus, TaskEndpointStatus
+from gmicloud._internal._enums import BuildStatus, TaskStatus, TaskEndpointStatus, ModelParameterType
 
 
 class BigFileMetadata(BaseModel):
@@ -70,6 +70,7 @@ class CreateArtifactRequest(BaseModel):
     artifact_name: str  # The name of the artifact to create.
     artifact_description: Optional[str] = ""  # Description of the artifact.
     artifact_tags: Optional[List[str]] = None  # Tags for the artifact, separated by commas.
+    model_parameters: Optional[List["ModelParameter"]] = None  # Parameters for the artifact.
 
 
 class CreateArtifactResponse(BaseModel):
@@ -158,6 +159,7 @@ class TemplateMetadata(BaseModel):
     update_at: Optional[str] = None  # Timestamp when the template was last updated.
     update_by: Optional[str] = ""  # ID of the user who last updated the template.
 
+
 class TemplateData(BaseModel):
     """
     Data for an artifact template.
@@ -165,6 +167,7 @@ class TemplateData(BaseModel):
     description: Optional[str] = ""  # Description of the artifact template.
     icon_link: Optional[str] = ""  # Link to the icon for the artifact template.
     image_link: Optional[str] = ""  # Link to the image for the artifact template.
+    model_parameters: Optional[List["ModelParameter"]] = None  # Parameters for the artifact template.
     name: Optional[str] = ""  # Name of the artifact template.
     ray: Optional["RayContent"] = None  # Template for Ray-based artifacts.
     resources: Optional["ResourcesTemplate"] = None  # Resource allocation template.
@@ -172,6 +175,19 @@ class TemplateData(BaseModel):
     volume_path: Optional[str] = ""  # Path to the volume where the artifact is stored.
 
 
+class ModelParameter(BaseModel):
+    """
+    Parameter for an artifact template.
+    """
+    category: Optional[str] = ""  # Category of the parameter.
+    display_name: Optional[str] = ""  # Display name of the parameter.
+    key: Optional[str] = ""  # Key for the parameter.
+    max: Optional[float] = 0  # Maximum value for the parameter.
+    min: Optional[float] = 0  # Minimum value for the parameter.
+    step: Optional[float] = 0  # Step value for the parameter.
+    type: Optional[ModelParameterType] = ModelParameterType.TEXT  # Type of the parameter (e.g., numeric, bool, text).
+    value: Optional[Union[int, float, bool, str]] = ""  # Default value for the parameter.
+
 class RayContent(BaseModel):
     deployment_name: Optional[str] = ""  # Name of the deployment.
     file_path: Optional[str] = ""  # Path to the task file in storage.
@@ -234,7 +250,6 @@ class RayTaskConfig(BaseModel):
     Configuration settings for Ray tasks.
     """
     artifact_id: Optional[str] = ""  # Associated artifact ID.
-    ray_version: Optional[str] = ""  # Version of Ray used.
     ray_cluster_image: Optional[str] = ""  # Docker image for the Ray cluster.
     file_path: Optional[str] = ""  # Path to the task file in storage.
     deployment_name: Optional[str] = ""  # Name of the deployment.
@@ -282,6 +297,7 @@ class TaskConfig(BaseModel):
     """
     Configuration data for a task.
     """
+    task_name: Optional[str] = ""  # Name of the task.
     ray_task_config: Optional[RayTaskConfig] = None  # Configuration for a Ray-based task.
     task_scheduling: Optional[TaskScheduling] = None  # Scheduling configuration for the task.
     create_timestamp: Optional[int] = 0  # Timestamp when the task was created.

gmicloud/client.py

@@ -8,7 +8,7 @@ from ._internal._client._iam_client import IAMClient
 from ._internal._manager._artifact_manager import ArtifactManager
 from ._internal._manager._task_manager import TaskManager
 from ._internal._manager._iam_manager import IAMManager
-from ._internal._enums import BuildStatus
+from ._internal._enums import BuildStatus, TaskStatus, TaskEndpointStatus
 from ._internal._models import Task, TaskConfig, RayTaskConfig, TaskScheduling, ReplicaResource
 
 logger = logging.getLogger(__name__)
@@ -38,80 +38,6 @@ class Client:
         self._task_manager = None
         self._iam_manager = None
 
-    def create_task_from_artifact_template(self, artifact_template_id: str, task_scheduling: TaskScheduling) -> Task:
-        """
-        Create a task from a template.
-
-        :param artifact_template_id: The ID of the artifact template to use.
-        :param task_scheduling: The scheduling configuration for the task.
-        :return: A `Task` object containing the details of the created task.
-        :rtype: Task
-        """
-        if not artifact_template_id or not artifact_template_id.strip():
-            raise ValueError("Artifact Template ID must be provided.")
-        if not task_scheduling:
-            raise ValueError("Task Scheduling must be provided.")
-
-        artifact_manager = self.artifact_manager
-        task_manager = self.task_manager
-
-        templates = artifact_manager.get_public_templates()
-        template = None
-        for v in templates:
-            if v.template_id == artifact_template_id:
-                template = v
-        if not template:
-            raise ValueError(f"Template with ID {artifact_template_id} not found.")
-        if not template.template_data:
-            raise ValueError("Template does not contain template data.")
-        if not template.template_data.ray:
-            raise ValueError("Template does not contain Ray configuration.")
-        if not template.template_data.resources:
-            raise ValueError("Template does not contain resource configuration.")
-
-        artifact_id = artifact_manager.create_artifact_from_template(artifact_template_id)
-
-        logger.info(f"Successfully created artifact from template, artifact_id: {artifact_id}")
-        # Wait for the artifact to be ready
-        while True:
-            try:
-                artifact = artifact_manager.get_artifact(artifact_id)
-                logger.info(f"Successfully got artifact info, 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:
-            # Create a task
-            task = task_manager.create_task(Task(
-                config=TaskConfig(
-                    ray_task_config=RayTaskConfig(
-                        ray_version=template.ray.version,
-                        file_path=template.ray.file_path,
-                        artifact_id=artifact_id,
-                        deployment_name=template.ray.deployment_name,
-                        replica_resource=ReplicaResource(
-                            cpu=template.resources.cpu,
-                            ram_gb=template.resources.memory,
-                            gpu=template.resources.gpu,
-                        ),
-                    ),
-                    task_scheduling=task_scheduling,
-                ),
-            ))
-
-            logger.info(f"Successfully created task, task_id: {task.task_id}")
-            # Start the task
-            task_manager.start_task(task.task_id)
-            logger.info(f"Successfully started task, task_id: {task.task_id}")
-        except Exception as e:
-            raise e
-
-        return task
-
     @property
     def artifact_manager(self):
         """
@@ -141,3 +67,181 @@ class Client:
         if self._iam_manager is None:
             self._iam_manager = IAMManager(self.iam_client)
         return self._iam_manager
+
+    # def list_templates(self) -> list[str]:
+    #     """
+    #     List all public templates.
+
+    #     :return: A list of template names.
+    #     :rtype: list[str]
+    #     """
+    #     template_names = []
+    #     try: 
+    #         templates = self.artifact_manager.get_public_templates()
+    #         for template in templates:
+    #             if template.template_data and template.template_data.name:
+    #                 template_names.append(template.template_data.name)
+    #         return template_names
+    #     except Exception as e:
+    #         logger.error(f"Failed to get artifact templates, Error: {e}")
+    #         return []
+        
+    # def wait_for_artifact_ready(self, artifact_id: str, timeout_s: int = 900) -> None:
+    #     """
+    #     Wait for an artifact to be ready.
+
+    #     :param artifact_id: The ID of the artifact to wait for.
+    #     :param timeout_s: The timeout in seconds.
+    #     :return: None
+    #     """
+    #     artifact_manager = self.artifact_manager
+    #     start_time = time.time()
+    #     while True:
+    #         try:
+    #             artifact = artifact_manager.get_artifact(artifact_id)
+    #             if artifact.build_status == BuildStatus.SUCCESS:
+    #                 return
+    #             elif artifact.build_status in [BuildStatus.FAILED, BuildStatus.TIMEOUT, BuildStatus.CANCELLED]:
+    #                 raise Exception(f"Artifact build failed, status: {artifact.build_status}")
+    #         except Exception as e:
+    #             logger.error(f"Failed to get artifact, Error: {e}")
+    #         if time.time() - start_time > timeout_s:
+    #             raise Exception(f"Artifact build takes more than {timeout_s // 60} minutes. Testing aborted.")
+    #         time.sleep(10)
+        
+    # def create_artifact_from_template(self, artifact_template_name: str) -> tuple[str, ReplicaResource]:
+    #     """
+    #     Create an artifact from a template.
+
+    #     :param artifact_template_name: The name of the template to use.
+    #     :return: A tuple containing the artifact ID and the recommended replica resources.
+    #     :rtype: tuple[str, ReplicaResource]
+    #     """
+    #     artifact_manager = self.artifact_manager
+
+    #     recommended_replica_resources = None
+    #     template_id = None
+    #     try:
+    #         templates = artifact_manager.get_public_templates()
+    #     except Exception as e:
+    #         logger.error(f"Failed to get artifact templates, Error: {e}")
+    #     for template in templates:
+    #         if template.template_data and template.template_data.name == artifact_template_name:
+    #             resources_template = template.template_data.resources
+    #             recommended_replica_resources = ReplicaResource(
+    #                 cpu=resources_template.cpu,
+    #                 ram_gb=resources_template.memory,
+    #                 gpu=resources_template.gpu,
+    #                 gpu_name=resources_template.gpu_name,
+    #             )
+    #             template_id = template.template_id
+    #             break
+    #     if not template_id:
+    #         raise ValueError(f"Template with name {artifact_template_name} not found.")
+    #     try: 
+    #         artifact_id = artifact_manager.create_artifact_from_template(template_id)
+    #         self.wait_for_artifact_ready(artifact_id)
+    #         return artifact_id, recommended_replica_resources
+    #     except Exception as e:
+    #         logger.error(f"Failed to create artifact from template, Error: {e}")
+    #         raise e
+        
+    # def create_task(self, artifact_id: str, replica_resources: ReplicaResource, task_scheduling: TaskScheduling) -> str:
+    #     """
+    #     Create a task.
+
+    #     :param artifact_id: The ID of the artifact to use.
+    #     :param replica_resources: The recommended replica resources.
+    #     :param task_scheduling: The scheduling configuration for the task.
+    #     :return: The ID of the created task.
+    #     :rtype: str
+    #     """
+    #     task_manager = self.task_manager
+    #     task = None
+    #     try:
+    #         task = task_manager.create_task(Task(
+    #             config=TaskConfig(
+    #                 ray_task_config=RayTaskConfig(
+    #                     artifact_id=artifact_id,
+    #                     file_path="serve",
+    #                     deployment_name="app",
+    #                     replica_resource=replica_resources,
+    #                 ),
+    #                 task_scheduling = task_scheduling,
+    #             ),
+    #         ))
+    #     except Exception as e:
+    #         logger.error(f"Failed to create task, Error: {e}")
+    #         raise e
+    #     return task.task_id 
+    
+    # def start_task_and_wait(self, task_id: str, timeout_s: int = 900) -> Task:
+    #     """
+    #     Start a task and wait for it to be ready.
+
+    #     :param task_id: The ID of the task to start.
+    #     :param timeout_s: The timeout in seconds.
+    #     :return: The task object.
+    #     :rtype: Task
+    #     """
+    #     task_manager = self.task_manager
+    #     # trigger start task
+    #     try:
+    #         task_manager.start_task(task_id)
+    #         logger.info(f"Started task ID: {task_id}")
+    #     except Exception as e:
+    #         logger.error(f"Failed to start task, Error: {e}")
+    #         raise e
+        
+    #     start_time = time.time()
+    #     while True:
+    #         try:
+    #             task = task_manager.get_task(task_id)
+    #             if task.task_status == TaskStatus.RUNNING:
+    #                 return task
+    #             elif task.task_status in [TaskStatus.NEEDSTOP, TaskStatus.ARCHIVED]:
+    #                 raise Exception(f"Unexpected task status after starting: {task.task_status}")
+    #             # Also check endpoint status. 
+    #             elif task.task_status == TaskStatus.RUNNING:
+    #                 if task.endpoint_info and task.endpoint_info.endpoint_status == TaskEndpointStatus.RUNNING:
+    #                     return task
+    #                 elif task.endpoint_info and task.endpoint_info.endpoint_status in [TaskEndpointStatus.UNKNOWN, TaskEndpointStatus.ARCHIVED]:
+    #                     raise Exception(f"Unexpected endpoint status after starting: {task.endpoint_info.endpoint_status}")
+    #                 else:
+    #                     logger.info(f"Pending endpoint starting. endpoint status: {task.endpoint_info.endpoint_status}")
+    #             else:
+    #                 logger.info(f"Pending task starting. Task status: {task.task_status}")
+
+    #         except Exception as e:
+    #             logger.error(f"Failed to get task, Error: {e}")
+    #         if time.time() - start_time > timeout_s:
+    #             raise Exception(f"Task creation takes more than {timeout_s // 60} minutes. Testing aborted.")
+    #         time.sleep(10)
+
+    # def stop_task(self, task_id: str, timeout_s: int = 900):
+    #     task_manager = self.task_manager
+    #     try:
+    #         self.task_manager.stop_task(task_id)
+    #         logger.info(f"Stopping task ID: {task_id}")
+    #     except Exception as e:
+    #         logger.error(f"Failed to stop task, Error: {e}")
+    #     task_manager = self.task_manager
+    #     start_time = time.time()
+    #     while True:
+    #         try:
+    #             task = task_manager.get_task(task_id)
+    #             if task.task_status == TaskStatus.IDLE:
+    #                 break
+    #         except Exception as e:
+    #             logger.error(f"Failed to get task, Error: {e}")
+    #         if time.time() - start_time > timeout_s:
+    #             raise Exception(f"Task stopping takes more than {timeout_s // 60} minutes. Testing aborted.")
+    #         time.sleep(10)
+
+    # def archive_task(self, task_id: str, timeout_s: int = 900):
+    #     task_manager = self.task_manager
+    #     try:
+    #         self.task_manager.archive_task(task_id)
+    #         logger.info(f"Archived task ID: {task_id}")
+    #     except Exception as e:
+    #         logger.error(f"Failed to archive task, Error: {e}")  

gmicloud-0.1.6.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.2
+Name: gmicloud
+Version: 0.1.6
+Summary: GMI Cloud Python SDK
+Author-email: GMI <support@gmicloud.ai>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# GMICloud SDK (Beta)
+
+## Overview
+Before you start: Our service and GPU resource is currenly invite-only so please contact our team (getstarted@gmicloud.ai) to get invited if you don't have one yet.
+
+The GMI Inference Engine SDK provides a Python interface for deploying and managing machine learning models in production environments. It allows users to create model artifacts, schedule tasks for serving models, and call inference APIs easily.
+
+This SDK streamlines the process of utilizing GMI Cloud capabilities such as deploying models with Kubernetes-based Ray services, managing resources automatically, and accessing model inference endpoints. With minimal setup, developers can focus on building ML solutions instead of infrastructure.
+
+## Features
+
+- Artifact Management: Easily create, update, and manage ML model artifacts.
+- Task Management: Quickly create, schedule, and manage deployment tasks for model inference.
+- Usage Data Retrieval : Fetch and analyze usage data to optimize resource allocation.
+
+## Installation
+
+To install the SDK, use pip:
+
+```bash
+pip install gmicloud
+```
+
+## Setup
+
+You must configure authentication credentials for accessing the GMI Cloud API. 
+To create account and get log in info please visit **GMI inference platform: https://inference-engine.gmicloud.ai/**.
+
+There are two ways to configure the SDK:
+
+### Option 1: Using Environment Variables
+
+Set the following environment variables:
+
+```shell
+export GMI_CLOUD_CLIENT_ID=<YOUR_CLIENT_ID>
+export GMI_CLOUD_EMAIL=<YOUR_EMAIL>
+export GMI_CLOUD_PASSWORD=<YOUR_PASSWORD>
+```
+
+### Option 2: Passing Credentials as Parameters
+
+Pass `client_id`, `email`, and `password` directly to the Client object when initializing it in your script:
+
+```python
+from gmicloud import Client
+
+client = Client(client_id="<YOUR_CLIENT_ID>", email="<YOUR_EMAIL>", password="<YOUR_PASSWORD>")
+```
+
+## Quick Start
+
+### 1. How to run the code in the example folder
+```bash
+cd path/to/gmicloud-sdk
+# Create a virtual environment
+python -m venv venv
+source venv/bin/activate
+
+pip install -r requirements.txt
+python -m examples.create_task_from_artifact_template.py
+```
+
+### 2. Create an inference task from an artifact template
+
+This is the simplest example to deploy an inference task using an existing artifact template:
+
+Up-to-date code in /examples/create_task_from_artifact_template.py
+
+```python
+from datetime import datetime
+import os
+import sys
+
+from gmicloud import *
+from examples.completion import call_chat_completion
+
+cli = Client()
+
+# List templates offered by GMI cloud 
+templates = cli.list_templates()
+print(f"Found {len(templates)} templates: {templates}")
+
+# Pick a template from the list
+pick_template = "Llama-3.1-8B"
+
+# Create Artifact from template
+artifact_id, recommended_replica_resources = cli.create_artifact_from_template(templates[0])
+print(f"Created artifact {artifact_id} with recommended replica resources: {recommended_replica_resources}")
+
+# Create Task based on Artifact
+task_id = cli.create_task(artifact_id, recommended_replica_resources, TaskScheduling(
+    scheduling_oneoff=OneOffScheduling(
+        trigger_timestamp=int(datetime.now().timestamp()),
+        min_replicas=1,
+        max_replicas=1,
+    )
+))
+task = cli.task_manager.get_task(task_id)
+print(f"Task created: {task.config.task_name}. You can check details at https://inference-engine.gmicloud.ai/user-console/task")
+
+# Start Task and wait for it to be ready
+cli.start_task_and_wait(task.task_id)
+
+# Testing with calling chat completion
+print(call_chat_completion(cli, task.task_id))
+
+```
+
+## API Reference
+
+### Client
+
+Represents the entry point to interact with GMI Cloud APIs.
+Client(
+client_id: Optional[str] = "",
+email: Optional[str] = "",
+password: Optional[str] = ""
+)
+
+### Artifact Management
+
+* get_artifact_templates(): Fetch a list of available artifact templates.
+* create_artifact_from_template(template_id: str): Create a model artifact from a given template.
+* get_artifact(artifact_id: str): Get details of a specific artifact.
+
+### Task Management
+
+* create_task_from_artifact_template(template_id: str, scheduling: TaskScheduling): Create and schedule a task using an
+  artifact template.
+* start_task(task_id: str): Start a task.
+* get_task(task_id: str): Retrieve the status and details of a specific task.
+
+## Notes & Troubleshooting
+k

{gmicloud-0.1.5.dist-info → gmicloud-0.1.6.dist-info}/RECORD

@@ -1,11 +1,11 @@
 gmicloud/__init__.py,sha256=aIgu4MAw4nExv781-pzSZLG8MscqAMZ5lM5fGyqg7QU,984
-gmicloud/client.py,sha256=RzI-T5FHMxb_OrDFadmi_WJ5EP6S1on3tR-z1ajyuPo,5598
+gmicloud/client.py,sha256=G0tD0xQnpqDKS-3l-AAU-K3FAHOsqsTzsAq2NVxiamY,10539
 gmicloud/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gmicloud/_internal/_config.py,sha256=qIH76TSyS3MQWe62LHI46RJhDnklNFisdajY75oUAqE,218
 gmicloud/_internal/_constants.py,sha256=Y085dwFlqdFkCf39iBfxz39QiiB7lX59ayNJjB86_m4,378
-gmicloud/_internal/_enums.py,sha256=5Z0MZksO1rjHVu24ZF29yYorYJjrYR45WKGL7_EGKUE,686
+gmicloud/_internal/_enums.py,sha256=5d6Z8TFJYCmhNI1TDbPpBbG1tNe96StIEH4tEw20RZk,789
 gmicloud/_internal/_exceptions.py,sha256=hScBq7n2fOit4_umlkabZJchY8zVbWSRfWM2Y0rLCbw,306
-gmicloud/_internal/_models.py,sha256=OsgRTdzFaMC8EdqLZGH9g66vPjgntV6Jg2eJo-P7SZE,16962
+gmicloud/_internal/_models.py,sha256=eArBzdhiMosLVZVUyoE_mvfxRS8yKPkuqhlDaa57Iog,17863
 gmicloud/_internal/_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gmicloud/_internal/_client/_artifact_client.py,sha256=-CyMdTauVovuv3whs8yUqmv3-WW2e9m2GoEG9D6eNbc,8374
 gmicloud/_internal/_client/_decorator.py,sha256=sy4gxzsUB6ORXHw5pqmMf7TTlK41Nmu1fhIhK2AIsbY,670
@@ -14,14 +14,14 @@ gmicloud/_internal/_client/_http_client.py,sha256=j--3emTjJ_l9CTdnkTbcpf7gYcUEl3
 gmicloud/_internal/_client/_iam_client.py,sha256=pgOXIqp9aJvcIUCEVkYPEyMUyxBftecojHAbs8Gbl94,7013
 gmicloud/_internal/_client/_task_client.py,sha256=69OqZC_kwSDkTSVVyi51Tn_OyUV6R0nin4z4gLfZ-Lg,6141
 gmicloud/_internal/_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gmicloud/_internal/_manager/_artifact_manager.py,sha256=yHNAcCPd-tFerSzDojdDuFDzk6SldbzLPGAW_hyDeF4,12568
+gmicloud/_internal/_manager/_artifact_manager.py,sha256=TBvGps__Kk1Ym7jztY3tNZ3XomKPrDIFPV7XyyLwHuw,15941
 gmicloud/_internal/_manager/_iam_manager.py,sha256=nAqPCaUfSXTnx2MEQa8e0YUOBFYWDRiETgK1PImdf4o,1167
-gmicloud/_internal/_manager/_task_manager.py,sha256=6dQ4yr22F3vljWkpa5hR5PQ3QuFGVU-pOnN1XwZQEBY,8304
+gmicloud/_internal/_manager/_task_manager.py,sha256=YDUcAdRkJhGumA1LLfpXfYs6jmLnev8P27UItPZHUBs,11268
 gmicloud/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gmicloud/tests/test_artifacts.py,sha256=q1jiTk5DN4G3LCLCO_8KbWArdc6RG3sETe1MCEt-vbI,16979
 gmicloud/tests/test_tasks.py,sha256=yL-aFf80ShgTyxEONTWh-xbWDf5XnUNtIeA5hYvhKM0,10963
 gmicloud/utils/uninstall_packages.py,sha256=zzuuaJPf39oTXWZ_7tUAGseoxocuCbbkoglJSD5yDrE,1127
-gmicloud-0.1.5.dist-info/METADATA,sha256=0lXsAQuoEisnxbuT9EfUbi42qlDL6IcZl7fggJNwIx4,7757
-gmicloud-0.1.5.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
-gmicloud-0.1.5.dist-info/top_level.txt,sha256=AZimLw3y0WPpLiSiOidZ1gD0dxALh-jQNk4fxC05hYE,9
-gmicloud-0.1.5.dist-info/RECORD,,
+gmicloud-0.1.6.dist-info/METADATA,sha256=rqwbl1_3RfzhdBpn9eb3u1My3pk10k7T3r23oEiTshY,4675
+gmicloud-0.1.6.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+gmicloud-0.1.6.dist-info/top_level.txt,sha256=AZimLw3y0WPpLiSiOidZ1gD0dxALh-jQNk4fxC05hYE,9
+gmicloud-0.1.6.dist-info/RECORD,,

{gmicloud-0.1.5.dist-info → gmicloud-0.1.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.1)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gmicloud-0.1.5.dist-info/METADATA

@@ -1,246 +0,0 @@
-Metadata-Version: 2.2
-Name: gmicloud
-Version: 0.1.5
-Summary: GMI Cloud Python SDK
-Author-email: GMI <gmi@gmitec.net>
-License: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-
-# GMICloud SDK (Beta)
-
-## Overview
-Before you start: Our service and GPU resource is currenly invite-only so please contact our team (getstarted@gmicloud.ai) to get invited if you don't have one yet.
-
-The GMI Inference Engine SDK provides a Python interface for deploying and managing machine learning models in production environments. It allows users to create model artifacts, schedule tasks for serving models, and call inference APIs easily.
-
-This SDK streamlines the process of utilizing GMI Cloud capabilities such as deploying models with Kubernetes-based Ray services, managing resources automatically, and accessing model inference endpoints. With minimal setup, developers can focus on building ML solutions instead of infrastructure.
-
-## Features
-
-- Artifact Management: Easily create, update, and manage ML model artifacts.
-- Task Management: Quickly create, schedule, and manage deployment tasks for model inference.
-- Usage Data Retrieval : Fetch and analyze usage data to optimize resource allocation.
-
-## Installation
-
-To install the SDK, use pip:
-
-```bash
-pip install gmicloud
-```
-
-## Setup
-
-You must configure authentication credentials for accessing the GMI Cloud API. There are two ways to configure the SDK:
-
-### Option 1: Using Environment Variables
-
-Set the following environment variables:
-
-```shell
-export GMI_CLOUD_CLIENT_ID=<YOUR_CLIENT_ID>
-export GMI_CLOUD_EMAIL=<YOUR_EMAIL>
-export GMI_CLOUD_PASSWORD=<YOUR_PASSWORD>
-export GMI_CLOUD_API_KEY=<YOUR_API_KEY>
-```
-
-### Option 2: Passing Credentials as Parameters
-
-Pass `client_id`, `email`, and `password` directly to the Client object when initializing it in your script:
-
-```python
-from gmicloud import Client
-
-client = Client(client_id="<YOUR_CLIENT_ID>", email="<YOUR_EMAIL>", password="<YOUR_PASSWORD>")
-```
-
-## Quick Start
-
-### 1. How to run the code in the example folder
-```bash
-cd path/to/gmicloud-sdk
-# Create a virtual environment
-python -m venv venv
-source venv/bin/activate
-
-pip install -r requirements.txt
-python -m examples.create_task_from_artifact_template.py
-```
-
-### 2. Create a Task from an Artifact Template
-
-This is the simplest example to deploy an existing artifact template:
-
-```python
-from datetime import datetime
-from gmicloud import Client, TaskScheduling, OneOffScheduling
-from examples.completion import call_chat_completion
-
-# Initialize the client
-client = Client()
-
-# Schedule and start a task from an artifact template
-task = client.create_task_from_artifact_template(
-    "qwen_2.5_14b_instruct_template_001",
-    TaskScheduling(
-        scheduling_oneoff=OneOffScheduling(
-            trigger_timestamp=int(datetime.now().timestamp()) + 10,  # Delay by 10 seconds
-            min_replicas=1,
-            max_replicas=10,
-        )
-    )
-)
-
-# Make a chat completion request via the task endpoint
-response = call_chat_completion(client, task.task_id)
-print(response)
-```
-
-### 3. Step-by-Step Example: Create Artifact, Task, and Query the Endpoint
-
-#### (a) Create an Artifact from a Template
-
-First, you’ll retrieve all templates and create an artifact based on the desired template (e.g., "Llama3.1 8B"):
-
-```python
-from gmicloud import *
-
-
-def create_artifact_from_template(client: Client) -> str:
-    artifact_manager = client.artifact_manager
-
-    # Get all artifact templates
-    templates = artifact_manager.get_public_templates()
-    for template in templates:
-        if template.artifact_template_id == "qwen_2.5_14b_instruct_template_001":
-            # 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 ""
-```
-
-#### (b) Create a Task from the Artifact
-
-Wait until the artifact becomes "ready" and then deploy it using task scheduling:
-
-```python
-from gmicloud import *
-import time
-from datetime import datetime
-
-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="2.40.0-py310-gpu",
-                    file_path="serve",
-                    artifact_id=artifact_id,
-                    deployment_name="app",
-                    replica_resource=ReplicaResource(
-                        cpu=10,
-                        ram_gb=100,
-                        gpu=1,
-                    ),
-                ),
-                task_scheduling=TaskScheduling(
-                    scheduling_oneoff=OneOffScheduling(
-                        trigger_timestamp=int(datetime.now().timestamp()) + 10,
-                        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
-```
-
-### (c) Query the Model Endpoint
-
-Once the task is running, use the endpoint for inference:
-
-```python
-from gmicloud import *
-from examples.completion import call_chat_completion
-
-# Initialize the Client
-cli = Client()
-
-# Create an artifact from a template
-artifact_id = create_artifact_from_template(cli)
-
-# Create a task and start it
-task_id = create_task_and_start(cli, artifact_id)
-
-# Call chat completion
-print(call_chat_completion(cli, task_id))
-```
-
-## API Reference
-
-### Client
-
-Represents the entry point to interact with GMI Cloud APIs.
-Client(
-client_id: Optional[str] = "",
-email: Optional[str] = "",
-password: Optional[str] = ""
-)
-
-### Artifact Management
-
-* get_artifact_templates(): Fetch a list of available artifact templates.
-* create_artifact_from_template(template_id: str): Create a model artifact from a given template.
-* get_artifact(artifact_id: str): Get details of a specific artifact.
-
-### Task Management
-
-* create_task_from_artifact_template(template_id: str, scheduling: TaskScheduling): Create and schedule a task using an
-  artifact template.
-* start_task(task_id: str): Start a task.
-* get_task(task_id: str): Retrieve the status and details of a specific task.
-
-## Notes & Troubleshooting
-
-* Ensure Credentials are Correct: Double-check your environment variables or parameters passed into the Client object.
-* Artifact Status: It may take a few minutes for an artifact or task to transition to the "running" state.
-* Inference Endpoint Readiness: Use the task endpoint only after the task status changes to "running".
-* Default OpenAI Key: By default, the OpenAI API base URL is derived from the endpoint provided by GMI.
-
-## Contributing
-
-We welcome contributions to enhance the SDK. Please follow these steps:
-
-1. Fork the repository.
-2. Create a new branch for your feature or bugfix.
-3. Commit changes with clear messages.
-4. Submit a pull request for review.