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

gmicloud/__init__.py

@@ -15,7 +15,7 @@ from ._internal._models import (
     OneOffScheduling,
     DailyScheduling,
     DailyTrigger,
-    ArtifactTemplate,
+    Template,
 )
 from ._internal._enums import (
     BuildStatus,
@@ -39,7 +39,7 @@ __all__ = [
     "OneOffScheduling",
     "DailyScheduling",
     "DailyTrigger",
-    "ArtifactTemplate",
+    "Template",
     "BuildStatus",
     "TaskEndpointStatus",
 ]

gmicloud/_internal/_client/_artifact_client.py

@@ -1,7 +1,7 @@
 from typing import List
 import logging
 from requests.exceptions import RequestException
-
+import json
 from ._http_client import HTTPClient
 from ._iam_client import IAMClient
 from ._decorator import handle_refresh_token
@@ -120,6 +120,39 @@ class ArtifactClient:
             logger.error(f"Failed to rebuild artifact {artifact_id}: {e}")
             return None
 
+    @handle_refresh_token
+    def add_env_parameters_to_artifact(self, artifact_id: str, env_parameters: dict[str, str]) -> None:
+        """
+        Updates an artifact by its ID.
+
+        :param artifact_id: The ID of the artifact to update.
+        :param request: The request object containing the updated artifact details.
+        """
+        try:
+            old_artifact = self.get_artifact(artifact_id)
+            if not old_artifact:
+                logger.error(f"Artifact {artifact_id} not found")
+                return
+            request = UpdateArtifactRequestBody(
+                artifact_description=old_artifact.artifact_metadata.artifact_description,
+                artifact_name=old_artifact.artifact_metadata.artifact_name,
+                artifact_tags=old_artifact.artifact_metadata.artifact_tags,
+                env_parameters=old_artifact.artifact_parameters.env_parameters,
+                model_parameters=old_artifact.artifact_parameters.model_parameters
+            )
+            new_env_parameters = [EnvParameter(key=k, value=v) for k, v in env_parameters.items()]
+            if not request.env_parameters:
+                request.env_parameters = []
+            request.env_parameters.extend(new_env_parameters)
+            response = self.client.put(
+                f"/update_artifact?artifact_id={artifact_id}",
+                self.iam_client.get_custom_headers(),
+                request.model_dump()
+            )
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to add env parameters to artifact {artifact_id}: {e}")
+            return 
+
     @handle_refresh_token
     def delete_artifact(self, artifact_id: str) -> Optional[DeleteArtifactResponse]:
         """
@@ -140,7 +173,7 @@ class ArtifactClient:
             return None
 
     @handle_refresh_token
-    def get_bigfile_upload_url(self, request: GetBigFileUploadUrlRequest) -> Optional[GetBigFileUploadUrlResponse]:
+    def get_bigfile_upload_url(self, request: ResumableUploadLinkRequest) -> Optional[ResumableUploadLinkResponse]:
         """
         Generates a pre-signed URL for uploading a large file.
 
@@ -156,7 +189,7 @@ class ArtifactClient:
                 logger.error("Empty response from /get_bigfile_upload_url")
                 return None
 
-            return GetBigFileUploadUrlResponse.model_validate(response)
+            return ResumableUploadLinkResponse.model_validate(response)
 
         except (RequestException, ValueError) as e:
             logger.error(f"Failed to generate upload URL: {e}")
@@ -186,12 +219,12 @@ class ArtifactClient:
             return None
 
     @handle_refresh_token
-    def get_public_templates(self) -> List[ArtifactTemplate]:
+    def get_public_templates(self) -> List[Template]:
         """
         Fetches all artifact templates.
 
-        :return: A list of ArtifactTemplate objects.
-        :rtype: List[ArtifactTemplate]
+        :return: A list of Template objects.
+        :rtype: List[Template]
         """
         try:
             response = self.client.get("/get_public_templates", self.iam_client.get_custom_headers())
@@ -201,7 +234,7 @@ class ArtifactClient:
                 return []
 
             try:
-                result = GetPublicTemplatesResponse.model_validate(response)
+                result = GetTemplatesResponse.model_validate(response)
                 return result.artifact_templates
             except ValueError as ve:
                 logger.error(f"Failed to validate response data: {ve}")

gmicloud/_internal/_client/_file_upload_client.py

@@ -1,8 +1,10 @@
 import os
 import requests
+import logging
 
 from .._exceptions import UploadFileError
 
+logger = logging.getLogger()
 
 class FileUploadClient:
     CHUNK_SIZE = 10 * 1024 * 1024  # 10MB Default Chunk Size
@@ -45,13 +47,13 @@ class FileUploadClient:
         """
         try:
             file_size = os.path.getsize(file_path)
-            print(f"File Size: {file_size} bytes")
+            logger.info(f"File {file_path} 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")
+                logger.info(f"Resuming uploading {file_path} from {start_byte} bytes")
 
             with open(file_path, "rb") as file:
                 while start_byte < file_size:
@@ -74,14 +76,15 @@ class FileUploadClient:
                     # 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}")
+                            f"Failed to upload file {file_path}, code:{resp.status_code} ,message: {resp.text}")
 
                     start_byte = end_byte + 1
-                    print(f"Uploaded {end_byte + 1}/{file_size} bytes")
+                    percentage = (start_byte / file_size) * 100
+                    logger.info(f"File {file_path} uploaded {end_byte + 1:,}/{file_size:,} bytes ({percentage:.2f}%)")
 
-                print("Upload completed successfully.")
+                logger.info(f"File {file_path} uploaded successfully.")
         except Exception as e:
-            raise UploadFileError(f"Failed to upload file: {str(e)}")
+            raise UploadFileError(f"Failed to upload file {file_path}, got error: {str(e)}")
 
     @staticmethod
     def _check_file_status(upload_url: str, file_size: int) -> str:
@@ -104,7 +107,7 @@ class FileUploadClient:
             if resp.status_code == 308:
                 range_header = resp.headers.get("Range")
                 if range_header:
-                    print(f"Server reports partial upload range: {range_header}")
+                    logger.info(f"Server reports partial upload range: {range_header}")
                 return range_header
 
             if resp.status_code in (200, 201):

gmicloud/_internal/_config.py

@@ -1,3 +1,9 @@
-ARTIFACT_SERVICE_BASE_URL = "https://ce-tot.gmicloud-dev.com/api/v1/ie/artifact"
-TASK_SERVICE_BASE_URL = "https://ce-tot.gmicloud-dev.com/api/v1/ie/task"
-IAM_SERVICE_BASE_URL = "https://ce-tot.gmicloud-dev.com/api/v1"
+# Dev environment
+# ARTIFACT_SERVICE_BASE_URL = "https://ce-tot.gmicloud-dev.com/api/v1/ie/artifact"
+# TASK_SERVICE_BASE_URL = "https://ce-tot.gmicloud-dev.com/api/v1/ie/task"
+# IAM_SERVICE_BASE_URL = "https://ce-tot.gmicloud-dev.com/api/v1"
+
+# Prod environment
+ARTIFACT_SERVICE_BASE_URL = "https://inference-engine.gmicloud.ai/api/v1/ie/artifact"
+TASK_SERVICE_BASE_URL = "https://inference-engine.gmicloud.ai/api/v1/ie/task"
+IAM_SERVICE_BASE_URL = "https://inference-engine.gmicloud.ai/api/v1"

gmicloud/_internal/_manager/_artifact_manager.py

@@ -2,11 +2,16 @@ import os
 import time
 from typing import List
 import mimetypes
+import concurrent.futures
+import re
+from tqdm import tqdm
+from tqdm.contrib.logging import logging_redirect_tqdm
 
 from .._client._iam_client import IAMClient
 from .._client._artifact_client import ArtifactClient
 from .._client._file_upload_client import FileUploadClient
 from .._models import *
+from .._manager.serve_command_utils import parse_server_command, extract_gpu_num_from_serve_command
 
 import logging
 
@@ -53,7 +58,12 @@ class ArtifactManager:
             self,
             artifact_name: str,
             description: Optional[str] = "",
-            tags: Optional[List[str]] = None
+            tags: Optional[List[str]] = None,
+            deployment_type: Optional[str] = "",
+            template_id: Optional[str] = "",
+            env_parameters: Optional[List["EnvParameter"]] = None,
+            model_description: Optional[str] = "",
+            model_parameters: Optional[List["ModelParameter"]] = None,
     ) -> CreateArtifactResponse:
         """
         Create a new artifact for a user.
@@ -69,11 +79,16 @@ class ArtifactManager:
 
         req = CreateArtifactRequest(artifact_name=artifact_name,
                                     artifact_description=description,
-                                    artifact_tags=tags, )
+                                    artifact_tags=tags,
+                                    deployment_type=deployment_type,
+                                    template_id=template_id,
+                                    env_parameters=env_parameters,
+                                    model_description=model_description,
+                                    model_parameters=model_parameters)
 
         return self.artifact_client.create_artifact(req)
 
-    def create_artifact_from_template(self, artifact_template_id: str) -> str:
+    def create_artifact_from_template(self, artifact_template_id: str, env_parameters: Optional[dict[str, str]] = None) -> str:
         """
         Create a new artifact for a user using a template.
 
@@ -85,11 +100,16 @@ class ArtifactManager:
         if not artifact_template_id or not artifact_template_id.strip():
             raise ValueError("Artifact template ID is required and cannot be empty.")
 
+    
         resp = self.artifact_client.create_artifact_from_template(artifact_template_id)
         if not resp or not resp.artifact_id:
             raise ValueError("Failed to create artifact from template.")
 
+        if env_parameters:
+            self.artifact_client.add_env_parameters_to_artifact(resp.artifact_id, env_parameters)
+
         return resp.artifact_id
+
     
     def create_artifact_from_template_name(self, artifact_template_name: str) -> tuple[str, ReplicaResource]:
         """
@@ -125,6 +145,56 @@ class ArtifactManager:
         except Exception as e:
             logger.error(f"Failed to create artifact from template, Error: {e}")
             raise e
+        
+    def create_artifact_for_serve_command_and_custom_model(self, template_name: str, artifact_name: str, serve_command: str, gpu_type: str, artifact_description: str = "") -> tuple[str, ReplicaResource]:
+        """
+        Create an artifact from a template and support custom model.
+        :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
+        picked_template = 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 == template_name:
+                picked_template = template
+                break
+        if not picked_template:
+            raise ValueError(f"Template with name {template_name} not found.")
+        
+        try:
+            if gpu_type not in ["H100", "H200"]:
+                raise ValueError("Only support A100 and H100 for now")
+            
+            type, env_vars, serve_args_dict = parse_server_command(serve_command)
+            if type.lower() not in template_name.lower():
+                raise ValueError(f"Template {template_name} does not support inference with {type}.")
+            num_gpus = extract_gpu_num_from_serve_command(serve_args_dict)
+            recommended_replica_resources = ReplicaResource(
+                cpu=num_gpus * 16,
+                ram_gb=num_gpus * 100,
+                gpu=num_gpus,
+                gpu_name=gpu_type,
+            )
+        except Exception as e:
+            raise ValueError(f"Failed to parse serve command, Error: {e}")
+
+        try:
+            env_vars = [
+                EnvParameter(key="SERVE_COMMAND", value=serve_command),
+                EnvParameter(key="GPU_TYPE", value=gpu_type),
+            ]
+            resp = self.create_artifact(artifact_name, artifact_description, deployment_type="template", template_id=picked_template.template_id, env_parameters=env_vars)
+            # Assume Artifact is already with BuildStatus.SUCCESS status
+            return resp.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:
         """
@@ -211,7 +281,7 @@ class ArtifactManager:
         model_file_name = os.path.basename(model_file_path)
         model_file_type = mimetypes.guess_type(model_file_path)[0]
 
-        req = GetBigFileUploadUrlRequest(artifact_id=artifact_id, file_name=model_file_name, file_type=model_file_type)
+        req = ResumableUploadLinkRequest(artifact_id=artifact_id, file_name=model_file_name, file_type=model_file_type)
 
         resp = self.artifact_client.get_bigfile_upload_url(req)
         if not resp or not resp.upload_link:
@@ -250,36 +320,64 @@ class ArtifactManager:
 
         FileUploadClient.upload_large_file(upload_link, file_path)
 
+
+    def upload_model_files_to_artifact(self, artifact_id: str, model_directory: str) -> None:
+        """
+        Upload model files to an existing artifact.
+
+        :param artifact_id: The ID of the artifact to upload the model files to.
+        :param model_directory: The path to the model directory.
+        """
+
+        # List all files in the model directory recursively
+        model_file_paths = []
+        for root, _, files in os.walk(model_directory):
+            for file in files:
+                model_file_paths.append(os.path.join(root, file))
+
+        def upload_file(model_file_path):
+            self._validate_file_path(model_file_path)
+            bigfile_upload_url_resp = self.artifact_client.get_bigfile_upload_url(
+                ResumableUploadLinkRequest(artifact_id=artifact_id, file_name=os.path.basename(model_file_path))
+            )
+            FileUploadClient.upload_large_file(bigfile_upload_url_resp.upload_link, model_file_path)
+
+        # Upload files in parallel with progress bar
+        with tqdm(total=len(model_file_paths), desc="Uploading model files") as progress_bar:
+            with logging_redirect_tqdm():
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    futures = {executor.submit(upload_file, path): path for path in model_file_paths}
+                    for future in concurrent.futures.as_completed(futures):
+                        try:
+                            future.result()
+                        except Exception as e:
+                            logger.error(f"Failed to upload file {futures[future]}, Error: {e}")
+                        progress_bar.update(1)
+
     def create_artifact_with_model_files(
             self,
             artifact_name: str,
             artifact_file_path: str,
-            model_file_paths: List[str],
+            model_directory: str,
             description: Optional[str] = "",
             tags: Optional[str] = None
     ) -> str:
         """
         Create a new artifact for a user and upload model files associated with the artifact.
-
         :param artifact_name: The name of the artifact.
         :param artifact_file_path: The path to the artifact file(Dockerfile+serve.py).
-        :param model_file_paths: The paths to the model files.
+        :param model_directory: The path to the model directory.
         :param description: An optional description for the artifact.
         :param tags: Optional tags associated with the artifact, as a comma-separated string.
         :return: The `artifact_id` of the created artifact.
-        :raises FileNotFoundError: If the provided `file_path` does not exist.
         """
         artifact_id = self.create_artifact_with_file(artifact_name, artifact_file_path, description, tags)
+        logger.info(f"Artifact created: {artifact_id}")
 
-        for model_file_path in model_file_paths:
-            self._validate_file_path(model_file_path)
-            bigfile_upload_url_resp = self.artifact_client.get_bigfile_upload_url(
-                GetBigFileUploadUrlRequest(artifact_id=artifact_id, model_file_path=model_file_path)
-            )
-            FileUploadClient.upload_large_file(bigfile_upload_url_resp.upload_link, model_file_path)
+        self.upload_model_files_to_artifact(artifact_id, model_directory)
 
         return artifact_id
-    
+
 
     def wait_for_artifact_ready(self, artifact_id: str, timeout_s: int = 900) -> None:
         """
@@ -304,12 +402,12 @@ class ArtifactManager:
             time.sleep(10)
 
     
-    def get_public_templates(self) -> List[ArtifactTemplate]:
+    def get_public_templates(self) -> List[Template]:
         """
         Fetch all artifact templates.
 
-        :return: A list of ArtifactTemplate objects.
-        :rtype: List[ArtifactTemplate]
+        :return: A list of Template objects.
+        :rtype: List[Template]
         """
         return self.artifact_client.get_public_templates()
         

gmicloud/_internal/_manager/_task_manager.py

@@ -41,7 +41,7 @@ class TaskManager:
 
         :return: A list of `Task` objects.
         """
-        resp = self.task_client.get_all_tasks(self.iam_client.get_user_id())
+        resp = self.task_client.get_all_tasks()
         if not resp or not resp.tasks:
             return []
 
@@ -63,6 +63,7 @@ class TaskManager:
         if not resp or not resp.task:
             raise ValueError("Failed to create task.")
 
+        logger.info(f"Task created: {resp.task.task_id}")
         return resp.task
 
     def create_task_from_file(self, artifact_id: str, config_file_path: str, trigger_timestamp: int = None) -> Task:
@@ -138,48 +139,54 @@ class TaskManager:
         return self.task_client.start_task(task_id)
     
 
-    def start_task_and_wait(self, task_id: str, timeout_s: int = 900) -> Task:
+    def wait_for_task(self, task_id: str, timeout_s: int = 900) -> Task:
         """
-        Start a task and wait for it to be ready.
+        Wait for a task to reach the RUNNING state or raise an exception if it fails.
 
-        :param task_id: The ID of the task to start.
+        :param task_id: The ID of the task to wait for.
         :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:
+                    if task.endpoint_info is not None 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}")
+                        if task.cluster_endpoints:
+                            for ce in task.cluster_endpoints:
+                                if ce.endpoint_status == TaskEndpointStatus.RUNNING:
+                                    return task
+                if task.task_status in [TaskStatus.NEEDSTOP, TaskStatus.ARCHIVED]:
+                    raise Exception(f"Unexpected task status after starting: {task.task_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 start_task_and_wait(self, task_id: str, timeout_s: int = 3600) -> 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
+        """
+        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
+
+        return self.wait_for_task(task_id, timeout_s)
 
     def stop_task(self, task_id: str) -> bool:
         """
@@ -190,16 +197,15 @@ class TaskManager:
         :raises ValueError: If `task_id` is invalid (None or empty string).
         """
         self._validate_not_empty(task_id, "Task ID")
+        return self.task_client.stop_task(task_id)
 
         
-    def stop_task_and_wait(self, task_id: str, timeout_s: int = 900):
-        task_manager = self.task_manager
+    def stop_task_and_wait(self, task_id: str, timeout_s: int = 3600):
         try:
-            self.task_manager.stop_task(task_id)
+            self.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:
@@ -212,7 +218,6 @@ class TaskManager:
                 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/_manager/serve_command_utils.py

@@ -0,0 +1,121 @@
+import shlex
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+def parse_server_command(cmd_str: str) -> tuple[str, dict, dict]:
+    """ 
+    parse server command
+    Maybe their are more than two types of server command
+    if not found, we can add more parse function
+    """
+    if "vllm serve" in cmd_str:
+        return ("vllm", *parse_server_vllm_command(cmd_str))
+    elif "sglang.launch_server" in cmd_str:
+        return ("sglang", *parse_server_sglang_command(cmd_str))
+    else:
+        raise ValueError(f"Unknown serve command: {cmd_str}")
+
+def extract_env_and_args(tokens: list) -> tuple[dict, list]:
+    """
+    Extract environment variables from the tokens list.
+    and add the params or flags to environment variables
+    """
+    env_vars = {}
+    while tokens and '=' in tokens[0] and not tokens[0].startswith('--'):
+        key, value = tokens.pop(0).split('=', 1)
+        env_vars[key] = value
+    for k, v in env_vars.items():
+        os.environ[k] = v
+    return env_vars, tokens
+
+def parse_flags_and_args(tokens: list) -> dict:
+    """ 
+    parse flags and args 
+    include three types --flag=value and --flag value annd --flag
+    """
+    result = {}
+    i = 0
+    while i < len(tokens):
+        token = tokens[i]
+        if token.startswith('--'):
+            if '=' in token:
+                key, value = token[2:].split('=', 1)
+                result[key] = value.strip("'\"")
+            elif i + 1 < len(tokens) and not tokens[i + 1].startswith('--'):
+                result[token[2:]] = tokens[i + 1].strip("'\"")
+                i += 1
+            elif i + 1 < len(tokens) and not tokens[i + 1].startswith('-'):
+                result[token[1:]] = tokens[i + 1].strip("'\"")
+                i += 1
+            else:
+                result[token[2:]] = True
+        else:
+            logger.warning(f"Ignoring unknown token: {token}")
+        i += 1
+    return result
+
+def parse_server_vllm_command(cmd_str: str) -> tuple[dict, dict]:
+    """ parse vllm command"""
+    tokens = shlex.split(cmd_str)
+    result = {}
+
+    # 提取环境变量
+    env_vars, tokens = extract_env_and_args(tokens)
+    if env_vars:
+        result["env_vars"] = env_vars
+
+    # vllm serve + model
+    if tokens[:2] != ['vllm', 'serve']:
+        raise ValueError("Invalid vllm serve command format. Example: vllm serve <model path>")
+
+    if len(tokens) < 3:
+        raise ValueError("Missing model path in vllm serve command. Example: vllm serve <model path>")
+    
+    model_path = tokens[2]
+    result["model-path"] = model_path
+    
+    flags = parse_flags_and_args(tokens[3:])
+    result.update(flags)
+    return (env_vars, result)
+
+def parse_server_sglang_command(cmd_str: str) -> tuple[dict, dict]:
+    """ parse sglang command"""
+    tokens = shlex.split(cmd_str)
+    result = {}
+
+    # 提取环境变量
+    env_vars, tokens = extract_env_and_args(tokens)
+    if env_vars:
+        result["env_vars"] = env_vars
+    # python3 -m sglang.launch_server
+    if tokens[:3] != ['python3', '-m', 'sglang.launch_server'] and tokens[:3] != ['python', '-m', 'sglang.launch_server']:
+        raise ValueError("Invalid sglang command format. Example: python3 -m sglang.launch_server")
+
+    flags = parse_flags_and_args(tokens[3:])
+    result.update(flags)
+    return (env_vars, result)
+
+def extract_gpu_num_from_serve_command(serve_args_dict: dict) -> int:
+    """ extract gpu num from serve command """            
+    cmd_tp_size = 1
+    cmd_dp_size = 1
+    if "tensor-parallel-size" in serve_args_dict:
+        cmd_tp_size = int(serve_args_dict["tensor-parallel-size"])
+    elif "tp" in serve_args_dict:
+        cmd_tp_size = int(serve_args_dict["tp"])
+    elif "tp-size" in serve_args_dict:
+        cmd_tp_size = int(serve_args_dict["tp-size"])
+    if "data-parallel-size" in serve_args_dict:
+        cmd_dp_size = int(serve_args_dict["data-parallel-size"])
+    elif "dp" in serve_args_dict:
+        cmd_dp_size = int(serve_args_dict["dp"])
+    elif "dp-size" in serve_args_dict:
+        cmd_dp_size = int(serve_args_dict["dp-size"])
+    if "pipeline_parallel_size" in serve_args_dict or "pp" in serve_args_dict:
+        raise ValueError("Pipeline parallel size is not supported.")
+    cmd_gpu_num = cmd_tp_size * cmd_dp_size
+    if cmd_gpu_num > 8:
+        raise ValueError("Only support up to 8 GPUs for single task replica.")
+    return cmd_gpu_num

gmicloud/_internal/_models.py

@@ -22,9 +22,13 @@ class ArtifactMetadata(BaseModel):
     user_id: Optional[str] = ""  # The user ID associated with this artifact.
     artifact_name: Optional[str] = ""  # Name of the artifact.
     artifact_description: Optional[str] = ""  # Description of the artifact.
-    artifact_tags: Optional[List[str]] = ""  # Comma-separated tags for categorizing the artifact.
+    artifact_tags: Optional[List[str]] = None  # Changed from List[str] with default to Optional[List[str]]
     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.
+    artifact_icon_link: Optional[str] = ""  # Link to the icon for the artifact.
+    is_public: Optional[bool] = False  # Indicates if the artifact is public.
+    org_id: Optional[str] = ""  # Organization ID associated with this artifact.
+    update_by: Optional[str] = ""  # User ID who last updated the artifact.
 
 
 class ArtifactData(BaseModel):
@@ -43,6 +47,29 @@ class ArtifactData(BaseModel):
     update_at: Optional[datetime]  # Timestamp when the artifact was last updated.
 
 
+class EnvParameter(BaseModel):
+    """
+    Environment parameter for an artifact.
+    """
+    key: str  # Key for the environment parameter.
+    value: str  # Value for the environment parameter.
+
+
+class ArtifactDetails(BaseModel):
+    """
+    Additional details for an artifact.
+    """
+    model_description: Optional[str] = ""  # Description of the model.
+
+
+class ArtifactParameters(BaseModel):
+    """
+    Parameters for an artifact.
+    """
+    env_parameters: Optional[List[EnvParameter]] = None  # Environment parameters.
+    model_parameters: Optional[List["ModelParameter"]] = None  # Model parameters.
+
+
 class Artifact(BaseModel):
     """
     Representation of an artifact, including its data and metadata.
@@ -53,6 +80,7 @@ class Artifact(BaseModel):
     build_status: Optional[BuildStatus] = None  # Status of the artifact build (e.g., in progress, succeeded, failed).
     artifact_data: Optional[ArtifactData] = None  # Data associated with the artifact.
     artifact_metadata: Optional[ArtifactMetadata] = None  # Metadata describing the artifact.
+    artifact_parameters: Optional[ArtifactParameters] = None  # Parameters for the artifact.
     big_files_metadata: Optional[List[BigFileMetadata]] = None  # Metadata for large files associated with the artifact.
 
 
@@ -69,7 +97,11 @@ 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.
+    artifact_tags: Optional[List[str]] = None  # Tags for the artifact.
+    deployment_type: Optional[str] = ""  # Deployment type
+    template_id: Optional[str] = ""  # Template ID
+    env_parameters: Optional[List["EnvParameter"]] = None  # Environment parameters.
+    model_description: Optional[str] = ""  # Description of the model.
     model_parameters: Optional[List["ModelParameter"]] = None  # Parameters for the artifact.
 
 
@@ -79,9 +111,10 @@ class CreateArtifactResponse(BaseModel):
     """
     artifact_id: str  # ID of the newly created artifact.
     upload_link: str  # URL to upload the artifact data.
+    artifact_icon_link: Optional[str] = ""  # Link to the icon for the artifact.
 
 
-class GetBigFileUploadUrlRequest(BaseModel):
+class ResumableUploadLinkRequest(BaseModel):
     """
     Request to generate a pre-signed URL for uploading large files.
     """
@@ -90,7 +123,7 @@ class GetBigFileUploadUrlRequest(BaseModel):
     file_type: Optional[str] = ""  # MIME type of the file.
 
 
-class GetBigFileUploadUrlResponse(BaseModel):
+class ResumableUploadLinkResponse(BaseModel):
     """
     Response containing a pre-signed upload URL for large files.
     """
@@ -98,6 +131,13 @@ class GetBigFileUploadUrlResponse(BaseModel):
     upload_link: str  # Pre-signed upload URL for the file.
 
 
+class RebuildArtifactRequest(BaseModel):
+    """
+    Request object for rebuilding an artifact.
+    """
+    artifact_id: str  # ID of the artifact to rebuild.
+
+
 class RebuildArtifactResponse(BaseModel):
     """
     Response object after rebuilding an artifact.
@@ -106,6 +146,91 @@ class RebuildArtifactResponse(BaseModel):
     build_status: BuildStatus  # Status of the artifact build (e.g., in progress, succeeded, failed).
 
 
+class EndpointInfo(BaseModel):
+    """
+    Additional information about the task endpoint.
+    """
+    endpoint_status: Optional[TaskEndpointStatus] = None  # Current status of the task (e.g., running, stopped).
+    endpoint_url: Optional[str] = ""  # URL for accessing the task endpoint.
+
+
+class GetAllArtifactsWithEndpointsResponse(BaseModel):
+    """
+    Response containing a list of all artifacts with their endpoints.
+    """
+    artifact_id: str  # Unique identifier for the artifact.
+    artifact_data: Optional[ArtifactData] = None  # Data associated with the artifact.
+    artifact_metadata: Optional[ArtifactMetadata] = None  # Metadata describing the artifact.
+    artifact_details: Optional[ArtifactDetails] = None  # Additional details about the artifact.
+    artifact_parameters: Optional[ArtifactParameters] = None  # Parameters for the artifact.
+    big_files_metadata: Optional[List[BigFileMetadata]] = None  # Metadata for large files.
+    endpoints: Optional[List[EndpointInfo]] = None  # Endpoints associated with the artifact.
+
+
+class GetArtifactResponse(BaseModel):
+    """
+    Response containing the details of an artifact.
+    """
+    artifact_id: str  # Unique identifier for the artifact.
+    artifact_link: Optional[str] = ""  # Link to access the artifact.
+    artifact_resource: Optional[str] = ""  # Resource associated with the artifact.
+    build_file_name: Optional[str] = ""  # Name of the file used for the build.
+    build_status: Optional[str] = ""  # Status of the artifact build.
+    artifact_metadata: Optional[ArtifactMetadata] = None  # Metadata describing the artifact.
+    artifact_parameters: Optional[ArtifactParameters] = None  # Parameters for the artifact.
+    big_files_metadata: Optional[List[BigFileMetadata]] = None  # Metadata for large files.
+
+
+class GetPublicArtifactsResponse(BaseModel):
+    """
+    Response containing public artifact details.
+    """
+    artifact_id: str  # Unique identifier for the artifact.
+    artifact_data: Optional[ArtifactData] = None  # Data associated with the artifact.
+    artifact_metadata: Optional[ArtifactMetadata] = None  # Metadata describing the artifact.
+    artifact_details: Optional[ArtifactDetails] = None  # Additional details about the artifact.
+    artifact_parameters: Optional[ArtifactParameters] = None  # Parameters for the artifact.
+    endpoints: Optional[List[EndpointInfo]] = None  # Endpoints associated with the artifact.
+
+
+class UpdateArtifactRequestBody(BaseModel):
+    """
+    Request object for updating an artifact.
+    """
+    artifact_name: Optional[str] = ""  # The name of the artifact.
+    artifact_description: Optional[str] = ""  # Description of the artifact.
+    artifact_tags: Optional[List[str]] = None  # Tags for the artifact.
+    env_parameters: Optional[List[EnvParameter]] = None  # Environment parameters.
+    model_description: Optional[str] = ""  # Description of the model.
+    model_parameters: Optional[List["ModelParameter"]] = None  # Parameters for the artifact.
+    need_update_icon: Optional[bool] = False  # Whether to update the artifact icon.
+
+
+class UpdateArtifactResponse(BaseModel):
+    """
+    Response object after updating an artifact.
+    """
+    artifact_id: str  # ID of the updated artifact.
+    status: str  # Status of the update operation.
+    artifact_icon_link: Optional[str] = ""  # Link to the icon for the artifact.
+
+
+class GetTemplatesResponse(BaseModel):
+    """
+    Response containing a list of artifact templates.
+    """
+    artifact_templates: list["Template"]  # List of artifact templates.
+
+
+class Template(BaseModel):
+    """
+    Template for creating an artifact.
+    """
+    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 DeleteArtifactResponse(BaseModel):
     """
     Response object after deleting an artifact.
@@ -132,22 +257,6 @@ class DeleteBigfileResponse(BaseModel):
     status: Optional[str] = ""  # Status of the deletion process.
 
 
-class GetPublicTemplatesResponse(BaseModel):
-    """
-    Response containing a list of artifact templates.
-    """
-    artifact_templates: list["ArtifactTemplate"]  # List of artifact templates.
-
-
-class ArtifactTemplate(BaseModel):
-    """
-    Template for creating an artifact.
-    """
-    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.
@@ -158,6 +267,7 @@ class TemplateMetadata(BaseModel):
     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.
+    status: Optional[str] = ""  # Status of the template.
 
 
 class TemplateData(BaseModel):
@@ -173,6 +283,7 @@ class TemplateData(BaseModel):
     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.
+    env_parameters: Optional[List["EnvParameter"]] = None  # Added missing field
 
 
 class ModelParameter(BaseModel):
@@ -204,8 +315,9 @@ class CreateArtifactFromTemplateRequest(BaseModel):
     """
     Request object to create a new artifact from a template.
     """
-    user_id: str  # The user ID creating the artifact.
+    # user_id: str  # The user ID creating the artifact.
     artifact_template_id: str  # The ID of the artifact template to use.
+    env_parameters: Optional[List["EnvParameter"]] = None  # Environment parameters.
 
 
 class CreateArtifactFromTemplateResponse(BaseModel):
@@ -304,14 +416,6 @@ class TaskConfig(BaseModel):
     last_update_timestamp: Optional[int] = 0  # Timestamp when the task was last updated.
 
 
-class EndpointInfo(BaseModel):
-    """
-    Additional information about the task endpoint.
-    """
-    endpoint_status: Optional[TaskEndpointStatus] = None  # Current status of the task (e.g., running, stopped).
-    endpoint_url: Optional[str] = ""  # URL for accessing the task endpoint.
-
-
 class UserPreference(BaseModel):
     """
     User preference for a task.
@@ -329,8 +433,8 @@ 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[TaskStatus] = ""  # Status of the task.
-    readiness_status: Optional[str] = ""  # Readiness status of the task.
+    task_status: Optional[TaskStatus] = None  # Status of the task.
+    readiness_status: Optional[str] = None  # Readiness status of the task.
     user_preference: Optional[UserPreference] = None  # User preference for the task.
 
 

gmicloud/tests/test_artifacts.py

@@ -131,34 +131,18 @@ class TestArtifactManager(unittest.TestCase):
         upload_link = "http://upload-link"
         bigfile_upload_link = "http://bigfile-upload-link"
         artifact_file_path = "./testdata/test.zip"
-        model_file_path = "./testdata/model.zip"
+        model_directory= "./testdata"
 
         mock_create_artifact.return_value = CreateArtifactResponse(artifact_id="1", upload_link=upload_link)
-        mock_get_bigfile_upload_url.return_value = GetBigFileUploadUrlResponse(artifact_id="1",
+        mock_get_bigfile_upload_url.return_value = ResumableUploadLinkResponse(artifact_id="1",
                                                                                upload_link=bigfile_upload_link)
 
         artifact_id = self.artifact_manager.create_artifact_with_model_files(artifact_name="artifact_name",
                                                                              artifact_file_path=artifact_file_path,
-                                                                             model_file_paths=[model_file_path])
+                                                                             model_directory=model_directory)
         self.assertEqual(artifact_id, "1")
         mock_upload_small_file.assert_called_once_with(upload_link, artifact_file_path, "application/zip")
-        mock_upload_large_file.assert_called_once_with(bigfile_upload_link, model_file_path)
-
-    @patch('gmicloud._internal._client._artifact_client.ArtifactClient.create_artifact')
-    @patch('gmicloud._internal._client._file_upload_client.FileUploadClient.upload_small_file')
-    def test_create_artifact_with_model_files_raises_file_not_found_error_for_model_file(self, mock_create_artifact,
-                                                                                         mock_upload_small_file):
-        upload_link = "http://upload-link"
-        artifact_file_path = "./testdata/test.zip"
-        model_file_path = "./testdata/nonexistent.zip"
-
-        mock_create_artifact.return_value = CreateArtifactResponse(artifact_id="1", upload_link=upload_link)
-
-        with self.assertRaises(FileNotFoundError) as context:
-            self.artifact_manager.create_artifact_with_model_files(artifact_name="artifact_name",
-                                                                   artifact_file_path=artifact_file_path,
-                                                                   model_file_paths=[model_file_path])
-        self.assertTrue(f"File not found: {model_file_path}" in str(context.exception))
+        self.assertEqual(mock_upload_large_file.call_count, 6) # 6 files in testdata directory
 
     @patch('gmicloud._internal._client._artifact_client.ArtifactClient.rebuild_artifact')
     def test_rebuild_artifact_rebuilds_successfully(self, mock_rebuild_artifact):
@@ -203,7 +187,7 @@ class TestArtifactManager(unittest.TestCase):
         upload_link = "http://upload-link"
         model_file_path = "./testdata/model.zip"
 
-        mock_get_bigfile_upload_url.return_value = GetBigFileUploadUrlResponse(artifact_id="1", upload_link=upload_link)
+        mock_get_bigfile_upload_url.return_value = ResumableUploadLinkResponse(artifact_id="1", upload_link=upload_link)
         upload_link = self.artifact_manager.get_bigfile_upload_url("1", model_file_path)
         self.assertEqual(upload_link, upload_link)
 
@@ -253,7 +237,7 @@ class TestArtifactManager(unittest.TestCase):
 
     @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"))]
+        mock_get_public_templates.return_value = [Template(template_id="1", template_data=TemplateData(name="Template1"))]
         templates = self.artifact_manager.get_public_templates()
         self.assertEqual(len(templates), 1)
         self.assertEqual(templates[0].template_id, "1")

{gmicloud-0.1.6.dist-info → gmicloud-0.1.7.dist-info}/METADATA

@@ -1,8 +1,8 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: gmicloud
-Version: 0.1.6
+Version: 0.1.7
 Summary: GMI Cloud Python SDK
-Author-email: GMI <support@gmicloud.ai>
+Author-email: GMI <gmi@gmitec.net>
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -10,7 +10,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 
-# GMICloud SDK (Beta)
+# GMICloud SDK
 
 ## 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.
@@ -45,7 +45,7 @@ There are two ways to configure the SDK:
 Set the following environment variables:
 
 ```shell
-export GMI_CLOUD_CLIENT_ID=<YOUR_CLIENT_ID>
+export GMI_CLOUD_CLIENT_ID=<YOUR_CLIENT_ID> # Pick what every ID you need.
 export GMI_CLOUD_EMAIL=<YOUR_EMAIL>
 export GMI_CLOUD_PASSWORD=<YOUR_PASSWORD>
 ```
@@ -73,7 +73,7 @@ pip install -r requirements.txt
 python -m examples.create_task_from_artifact_template.py
 ```
 
-### 2. Create an inference task from an artifact template
+### 2. Example of create an inference task from an artifact template
 
 This is the simplest example to deploy an inference task using an existing artifact template:
 
@@ -119,6 +119,97 @@ print(call_chat_completion(cli, task.task_id))
 
 ```
 
+### 3. Example of creating an inference task based on custom model with local vllm / SGLang serve command
+* Full example is available at [examples/inference_task_with_custom_model.py](https://github.com/GMISWE/python-sdk/blob/main/examples/inference_task_with_custom_model.py)
+
+1. Prepare custom model checkpoint (using a model downloaded from HF as an example)
+
+```python
+# Download model from huggingface
+from huggingface_hub import snapshot_download
+
+model_name = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
+model_checkpoint_save_dir = "files/model_garden"
+snapshot_download(repo_id=model_name, local_dir=model_checkpoint_save_dir)
+```
+
+2. Find a template of specific SGLang version
+
+```python
+# export GMI_CLOUD_CLIENT_ID=<YOUR_CLIENT_ID>
+# export GMI_CLOUD_EMAIL=<YOUR_EMAIL>
+# export GMI_CLOUD_PASSWORD=<YOUR_PASSWORD>
+cli = Client()
+
+# List templates offered by GMI cloud 
+templates = cli.artifact_manager.list_public_template_names()
+print(f"Found {len(templates)} templates: {templates}")
+```
+
+3. Pick a template (e.g. SGLang 0.4.5) and prepare a local serve command
+
+```python
+# Example for vllm server
+picked_template_name = "gmi_vllm_0.8.4"
+serve_command = "vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B --trust-remote-code --gpu-memory-utilization 0.8"
+
+# Example for sglang server
+picked_template_name = "gmi_sglang_0.4.5.post1"
+serve_command = "python3 -m sglang.launch_server --model-path deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B --trust-remote-code --mem-fraction-static 0.8 --tp 2"
+```
+
+4. Create an artifact and upload custom model. The artifact can be reused to create inference tasks later. Artifact also suggests recommended resources for each inference server replica
+
+```python
+artifact_id, recommended_replica_resources = cli.artifact_manager.create_artifact_from_template_name(
+    artifact_template_name=picked_template_name,
+    env_parameters={
+        "SERVER_COMMAND": serve_command,
+        "GPU_TYPE": "H100",
+    }
+)
+print(f"Created artifact {artifact_id} with recommended resources: {recommended_replica_resources}")
+
+# Upload model files to artifact
+cli.artifact_manager.upload_model_files_to_artifact(artifact_id, model_checkpoint_save_dir)
+```
+
+5. Create Inference task (defining min/max inference replica), start and wait
+
+```python
+new_task = Task(
+    config=TaskConfig(
+        ray_task_config=RayTaskConfig(
+            artifact_id=artifact_id,
+            file_path="serve",
+            deployment_name="app",
+            replica_resource=recommended_replica_resources,
+        ),
+        task_scheduling = TaskScheduling(
+            scheduling_oneoff=OneOffScheduling(
+                trigger_timestamp=int(datetime.now().timestamp()),
+                min_replicas=1,
+                max_replicas=4,
+            )
+        ),
+    ),
+)
+task = cli.task_manager.create_task(new_task)
+task_id = task.task_id
+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.task_manager.start_task_and_wait(task_id)
+```
+
+6. Test with sample chat completion request
+
+```python
+print(call_chat_completion(cli, task_id))
+```
+
+
 ## API Reference
 
 ### Client
@@ -144,4 +235,3 @@ password: Optional[str] = ""
 * get_task(task_id: str): Retrieve the status and details of a specific task.
 
 ## Notes & Troubleshooting
-k

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

@@ -1,27 +1,28 @@
-gmicloud/__init__.py,sha256=aIgu4MAw4nExv781-pzSZLG8MscqAMZ5lM5fGyqg7QU,984
+gmicloud/__init__.py,sha256=xSzrAxiby5Te20yhy1ZylGHmQKVV_w1QjFe6D99VZxw,968
 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/_config.py,sha256=BenHiCnedpHA5phz49UWBXa1mg_q9W8zYs7A8esqGcU,494
 gmicloud/_internal/_constants.py,sha256=Y085dwFlqdFkCf39iBfxz39QiiB7lX59ayNJjB86_m4,378
 gmicloud/_internal/_enums.py,sha256=5d6Z8TFJYCmhNI1TDbPpBbG1tNe96StIEH4tEw20RZk,789
 gmicloud/_internal/_exceptions.py,sha256=hScBq7n2fOit4_umlkabZJchY8zVbWSRfWM2Y0rLCbw,306
-gmicloud/_internal/_models.py,sha256=eArBzdhiMosLVZVUyoE_mvfxRS8yKPkuqhlDaa57Iog,17863
+gmicloud/_internal/_models.py,sha256=2l65aZdQxyXlY0Dj23P6NFf59_zopgf9OoUMLAz5T2U,22685
 gmicloud/_internal/_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gmicloud/_internal/_client/_artifact_client.py,sha256=-CyMdTauVovuv3whs8yUqmv3-WW2e9m2GoEG9D6eNbc,8374
+gmicloud/_internal/_client/_artifact_client.py,sha256=0lyHAdUybN8A1mEwZ7p1yK2yQEyoDG2vTB4Qe5RI2ik,9974
 gmicloud/_internal/_client/_decorator.py,sha256=sy4gxzsUB6ORXHw5pqmMf7TTlK41Nmu1fhIhK2AIsbY,670
-gmicloud/_internal/_client/_file_upload_client.py,sha256=1JRs4X57S3EScPIP9w2DC1Uo6_Wbcjumcw3nVM7uIGM,4667
+gmicloud/_internal/_client/_file_upload_client.py,sha256=r29iXG_0DOi-uTLu9plpfZMWGqOck_AdDHJZprcf8uI,4918
 gmicloud/_internal/_client/_http_client.py,sha256=j--3emTjJ_l9CTdnkTbcpf7gYcUEl341pv2O5cU67l0,5741
 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=TBvGps__Kk1Ym7jztY3tNZ3XomKPrDIFPV7XyyLwHuw,15941
+gmicloud/_internal/_manager/_artifact_manager.py,sha256=yK4veVwCY1cipy3rdnGvhnKNvkBx3SYYpHKqzjtXJn0,20731
 gmicloud/_internal/_manager/_iam_manager.py,sha256=nAqPCaUfSXTnx2MEQa8e0YUOBFYWDRiETgK1PImdf4o,1167
-gmicloud/_internal/_manager/_task_manager.py,sha256=YDUcAdRkJhGumA1LLfpXfYs6jmLnev8P27UItPZHUBs,11268
+gmicloud/_internal/_manager/_task_manager.py,sha256=zBW_TkYhbSvAc_p7Q3z6Vgl2Cayv8zIkawTT6OcB4x4,11291
+gmicloud/_internal/_manager/serve_command_utils.py,sha256=xjB6B9CNAmohou41H755iCCgkLNrjvdnu9NcJApTm1k,4373
 gmicloud/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gmicloud/tests/test_artifacts.py,sha256=q1jiTk5DN4G3LCLCO_8KbWArdc6RG3sETe1MCEt-vbI,16979
+gmicloud/tests/test_artifacts.py,sha256=w0T0EpATIGLrSUPaBfTZ2ZC_X2XeaTlFEi3DZ4evIcE,15825
 gmicloud/tests/test_tasks.py,sha256=yL-aFf80ShgTyxEONTWh-xbWDf5XnUNtIeA5hYvhKM0,10963
 gmicloud/utils/uninstall_packages.py,sha256=zzuuaJPf39oTXWZ_7tUAGseoxocuCbbkoglJSD5yDrE,1127
-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.7.dist-info/METADATA,sha256=LFLXvJeQ9ocyJQ8hFbTaNZAWJ7NvsO7FCN4tyaN5YY8,7927
+gmicloud-0.1.7.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+gmicloud-0.1.7.dist-info/top_level.txt,sha256=AZimLw3y0WPpLiSiOidZ1gD0dxALh-jQNk4fxC05hYE,9
+gmicloud-0.1.7.dist-info/RECORD,,

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

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