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

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, TaskEndpointStatus
+from gmicloud._internal._enums import BuildStatus, TaskStatus, TaskEndpointStatus, ModelParameterType
 
 
 class BigFileMetadata(BaseModel):
@@ -24,6 +24,7 @@ class ArtifactMetadata(BaseModel):
     artifact_description: Optional[str] = ""  # Description of the artifact.
     artifact_tags: Optional[List[str]] = ""  # Comma-separated tags for categorizing the artifact.
     artifact_volume_path: Optional[str] = ""  # Path to the volume where the artifact is stored.
+    artifact_template_id: Optional[str] = ""  # The template ID used to create this artifact.
 
 
 class ArtifactData(BaseModel):
@@ -69,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):
@@ -130,7 +132,7 @@ class DeleteBigfileResponse(BaseModel):
     status: Optional[str] = ""  # Status of the deletion process.
 
 
-class GetArtifactTemplatesResponse(BaseModel):
+class GetPublicTemplatesResponse(BaseModel):
     """
     Response containing a list of artifact templates.
     """
@@ -141,24 +143,61 @@ class ArtifactTemplate(BaseModel):
     """
     Template for creating an artifact.
     """
-    artifact_template_id: str  # Unique identifier for the artifact template.
-    artifact_description: Optional[str] = ""  # Description of the artifact template.
-    artifact_name: Optional[str] = ""  # Name of the artifact template.
-    artifact_tags: Optional[List[str]] = None  # Tags associated with the artifact template.
-    ray: Optional["RayTemplate"] = None  # Template for Ray-based artifacts.
+    template_id: str  # Unique identifier for the artifact template.
+    template_data: Optional["TemplateData"] = None  # Data for the artifact template.
+    template_metadata: Optional["TemplateMetadata"] = None  # Metadata for the artifact template.
+
+
+class TemplateMetadata(BaseModel):
+    """
+    Metadata for an artifact template.
+    """
+    create_at: Optional[str] = None  # Timestamp when the template was created.
+    create_by: Optional[str] = ""  # ID of the user who created the template.
+    create_by_org_id: Optional[str] = ""  # ID of the organization to which the user belongs.
+    is_public: Optional[bool] = False  # Indicates if the template is public.
+    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.
+    """
+    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.
+    tags: Optional[List[str]] = None  # Tags associated with the artifact template.
+    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 RayTemplate(BaseModel):
+class RayContent(BaseModel):
     deployment_name: Optional[str] = ""  # Name of the deployment.
     file_path: Optional[str] = ""  # Path to the task file in storage.
-    version: Optional[str] = ""  # Version of Ray used.
 
 
 class ResourcesTemplate(BaseModel):
     cpu: Optional[int] = 0  # Number of CPU cores allocated.
     memory: Optional[int] = 0  # Amount of RAM (in GB) allocated.
     gpu: Optional[int] = 0  # Number of GPUs allocated.
+    gpu_name: Optional[str] = ""  # Type the GPU allocated.
 
 
 class CreateArtifactFromTemplateRequest(BaseModel):
@@ -211,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.
@@ -259,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.
@@ -290,7 +329,7 @@ class Task(BaseModel):
     config: Optional[TaskConfig] = None  # Configuration data for the task.
     endpoint_info: Optional[EndpointInfo] = None  # Additional information about the task endpoint.
     cluster_endpoints: Optional[List[EndpointInfo]] = None  # Endpoints for the task cluster.
-    task_status: Optional[str] = ""  # Status of the task.
+    task_status: Optional[TaskStatus] = ""  # Status of the task.
     readiness_status: Optional[str] = ""  # Readiness status of the task.
     user_preference: Optional[UserPreference] = None  # User preference for the task.
 
@@ -373,3 +412,73 @@ class LoginRequest(BaseModel):
     """
     email: str  # User email.
     password: str  # User password.
+
+
+class User(BaseModel):
+    """
+    User information.
+    """
+    id: Optional[str] = ""  # User ID.
+    email: Optional[str] = ""  # User email.
+    firstName: Optional[str] = ""  # User first name.
+    lastName: Optional[str] = ""  # User last name.
+
+
+class Organization(BaseModel):
+    """
+    Organization information.
+    """
+    id: Optional[str] = ""  # Organization ID.
+    role: Optional[str] = ""  # Organization role.
+
+
+class ProfileResponse(BaseModel):
+    """
+    Response object for user profile.
+    """
+    user: User  # User information.
+    organization: Organization  # Organization information.
+
+
+class CreateAPIKeyRequest(BaseModel):
+    """
+    Request object for creating an API key.
+    """
+    name: str  # Name of the API key.
+    type: Optional[str] = ""  # Type of the API key.
+    expiresAt: Optional[int] = 0  # Expiration timestamp for the API key.
+
+
+class CreateAPIKeyResponse(BaseModel):
+    """
+    Response object for creating an API key.
+    """
+    key: str  # The created API key.
+
+
+class APIKey(BaseModel):
+    """
+    API key information.
+    """
+    id: Optional[str] = ""  # API key ID.
+    name: Optional[str] = ""  # API key name.
+    type: Optional[str] = ""  # API key type.
+    partialKey: Optional[str] = ""  # Partial key for the API key.
+    expiresAt: Optional[int] = 0  # Expiration timestamp for the API key.
+    createdAt: Optional[int] = 0  # Creation timestamp for the API key.
+    owner: Optional[User] = None  # Owner of the API key.
+
+
+class GetAPIKeysResponse(BaseModel):
+    """
+    Response object for getting a list of API keys.
+    """
+    keys: list[APIKey]  # List of API keys.
+
+
+class GetSelfAPIKeyResponse(BaseModel):
+    """
+    Response object for getting the API key of the current user.
+    """
+    key: APIKey  # The API key of the current user.
+    organization: Optional[Organization] = None  # Organization information.

gmicloud/client.py

@@ -1,14 +1,18 @@
 import os
 import time
+import logging
 
 from typing import Optional
 
 from ._internal._client._iam_client import IAMClient
 from ._internal._manager._artifact_manager import ArtifactManager
 from ._internal._manager._task_manager import TaskManager
-from ._internal._enums import BuildStatus
+from ._internal._manager._iam_manager import IAMManager
+from ._internal._enums import BuildStatus, TaskStatus, TaskEndpointStatus
 from ._internal._models import Task, TaskConfig, RayTaskConfig, TaskScheduling, ReplicaResource
 
+logger = logging.getLogger(__name__)
+
 
 class Client:
     def __init__(self, client_id: Optional[str] = "", email: Optional[str] = "", password: Optional[str] = ""):
@@ -32,74 +36,7 @@ class Client:
         # Managers are lazily initialized through private attributes
         self._artifact_manager = None
         self._task_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_artifact_templates()
-        template = None
-        for v in templates:
-            if v.artifact_template_id == artifact_template_id:
-                template = v
-        if not template:
-            raise ValueError(f"Template with ID {artifact_template_id} not found.")
-        if not template.ray:
-            raise ValueError("Template does not contain Ray configuration.")
-        if not template.resources:
-            raise ValueError("Template does not contain resource configuration.")
-
-        artifact_id = artifact_manager.create_artifact_from_template(artifact_template_id)
-        # 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:
-            # 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,
-                ),
-            ))
-
-            # Start the task
-            task_manager.start_task(task.task_id)
-        except Exception as e:
-            raise e
-
-        return task
+        self._iam_manager = None
 
     @property
     def artifact_manager(self):
@@ -120,3 +57,191 @@ class Client:
         if self._task_manager is None:
             self._task_manager = TaskManager(self.iam_client)
         return self._task_manager
+
+    @property
+    def iam_manager(self):
+        """
+        Lazy initialization for IAMManager.
+        Ensures the Client instance controls its lifecycle.
+        """
+        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/tests/test_artifacts.py

@@ -251,24 +251,23 @@ class TestArtifactManager(unittest.TestCase):
             self.artifact_manager.delete_bigfile("nonexistent_id", "file.txt")
         self.assertTrue("Artifact not found" in str(context.exception))
 
-    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_artifact_templates')
-    def test_get_artifact_templates_returns_templates(self, mock_get_artifact_templates):
-        mock_get_artifact_templates.return_value = GetArtifactTemplatesResponse(
-            artifact_templates=[ArtifactTemplate(artifact_template_id="1", artifact_name="Template1")])
-        templates = self.artifact_manager.get_artifact_templates()
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_public_templates')
+    def test_get_artifact_templates_returns_templates(self, mock_get_public_templates):
+        mock_get_public_templates.return_value = [ArtifactTemplate(template_id="1", template_data=TemplateData(name="Template1"))]
+        templates = self.artifact_manager.get_public_templates()
         self.assertEqual(len(templates), 1)
-        self.assertEqual(templates[0].artifact_template_id, "1")
-        self.assertEqual(templates[0].artifact_name, "Template1")
+        self.assertEqual(templates[0].template_id, "1")
+        self.assertEqual(templates[0].template_data.name, "Template1")
 
-    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_artifact_templates')
-    def test_get_artifact_templates_returns_empty_list_when_no_templates(self, mock_get_artifact_templates):
-        mock_get_artifact_templates.return_value = GetArtifactTemplatesResponse(artifact_templates=[])
-        templates = self.artifact_manager.get_artifact_templates()
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_public_templates')
+    def test_get_artifact_templates_returns_empty_list_when_no_templates(self, mock_get_public_templates):
+        mock_get_public_templates.return_value = []
+        templates = self.artifact_manager.get_public_templates()
         self.assertEqual(len(templates), 0)
 
-    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_artifact_templates')
-    def test_get_artifact_templates_raises_error_on_failure(self, mock_get_artifact_templates):
-        mock_get_artifact_templates.side_effect = Exception("Failed to fetch templates")
+    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.get_public_templates')
+    def test_get_artifact_templates_raises_error_on_failure(self, mock_get_public_templates):
+        mock_get_public_templates.side_effect = Exception("Failed to fetch templates")
         with self.assertRaises(Exception) as context:
-            self.artifact_manager.get_artifact_templates()
+            self.artifact_manager.get_public_templates()
         self.assertTrue("Failed to fetch templates" in str(context.exception))

gmicloud/tests/test_tasks.py

@@ -72,7 +72,7 @@ class TestTaskManager(unittest.TestCase):
                 'create_timestamp': 1734951094,
                 'last_update_timestamp': 1734975798
             },
-            'task_status': '',
+            'task_status': 'running',
             'readiness_status': '',
             'info': {
                 'endpoint_status': 'ready',

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