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

gmicloud/_internal/_client/_auth_config.py

@@ -0,0 +1,78 @@
+import os
+import jwt
+import time
+import json
+import logging
+import threading
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+CONFIG_FILE_NAME = ".gmicloud.config.json"
+
+# create the thread lock object56
+lock = threading.Lock()
+
+def _read_config_file()->dict|None:
+    """Read the config file."""
+    base_dir = Path.home()
+    config_file_path =os.path.join(base_dir,CONFIG_FILE_NAME)
+    if not os.path.exists(config_file_path):
+        return None
+    with lock:
+        # open the config file, read mode with lock
+        with open(config_file_path,"r") as fr:
+            return json.loads(fr.read())
+
+
+def _write_config_file(config_file_path:str,config_dic:dict)->None:
+    """Write the config file."""
+    with lock:
+        # open the config file, write mode with lock
+        with open(config_file_path,"w") as fw:
+            # transform the config dictionary to JSON format and write it to the file
+            fw.write(json.dumps(config_dic))
+
+
+def write_user_refresh_token_to_system_config(email:str,refresh_token:str)->bool:
+    """Write the user refresh token to the system config file."""
+    base_dir = Path.home()
+    config_file_path = os.path.join(base_dir,CONFIG_FILE_NAME)
+    try:
+        # check the config file is exists. if not, create it, if yes, update the refresh token
+        if not os.path.exists(config_file_path):
+            config_dic = { email : {"refresh_token": refresh_token} }
+            _write_config_file(config_file_path,config_dic)
+        else:
+            config_dic = _read_config_file()
+            if not config_dic.get(email):
+                config_dic[email] = dict()
+            config_dic[email] = {"refresh_token": refresh_token}
+            _write_config_file(config_file_path,config_dic)
+    except Exception as e:
+        logger.error("write file wrong :", e)
+        return False
+    return True
+
+
+def get_user_refresh_token_from_system_config(email:str)->str|None:
+    """Get the user refresh token from the system config file."""
+    config_dic = _read_config_file()
+    if not config_dic or not config_dic.get(email):
+        return None
+    return config_dic[email]["refresh_token"]
+
+
+def _parese_refresh_token(refresh_token:str)->dict:
+    """Parse the refresh token."""
+    return jwt.decode(refresh_token, options={"verify_signature": False})
+
+
+def is_refresh_token_expired(refresh_token:str)->bool:
+    """Check the refresh token is expired. if expired, return True, else return False."""
+    try:
+        refresh_token_time = _parese_refresh_token(refresh_token)['exp']
+    except Exception as e:
+        logger.error("parse refresh token wrong :", e)
+        return True
+    return refresh_token_time < time.time()

gmicloud/_internal/_client/_iam_client.py

@@ -6,7 +6,11 @@ from ._http_client import HTTPClient
 from .._config import IAM_SERVICE_BASE_URL
 from .._models import *
 from .._constants import CLIENT_ID_HEADER, AUTHORIZATION_HEADER
-
+from ._auth_config import (
+    get_user_refresh_token_from_system_config,
+    write_user_refresh_token_to_system_config,
+    is_refresh_token_expired
+)
 logger = logging.getLogger(__name__)
 
 
@@ -38,42 +42,50 @@ class IAMClient:
         Returns True if login is successful, otherwise False.
         """
         try:
-            custom_headers = {CLIENT_ID_HEADER: self._client_id}
-            req = AuthTokenRequest(email=self._email, password=self._password)
-            auth_tokens_result = self.client.post("/me/auth-tokens", custom_headers, req.model_dump())
-
-            if not auth_tokens_result:
-                logger.error("Login failed: Received empty response from auth-tokens endpoint")
-                return False
-
-            auth_tokens_resp = AuthTokenResponse.model_validate(auth_tokens_result)
-
-            # Handle 2FA
-            if auth_tokens_resp.is2FARequired:
-                for attempt in range(3):
-                    code = input(f"Attempt {attempt + 1}/3: Please enter the 2FA code: ")
-                    create_session_req = CreateSessionRequest(
-                        type="native", authToken=auth_tokens_resp.authToken, otpCode=code
-                    )
-                    try:
-                        session_result = self.client.post("/me/sessions", custom_headers,
-                                                          create_session_req.model_dump())
-                        if session_result:
-                            break
-                    except RequestException:
-                        logger.warning("Invalid 2FA code, please try again.")
-                        if attempt == 2:
-                            logger.error("Failed to create session after 3 incorrect 2FA attempts.")
-                            return False
+            # Check config refresh token is available and is not expired, if yes ,refresh it
+            temp_refresh_token = get_user_refresh_token_from_system_config(self._email)
+            if temp_refresh_token and not is_refresh_token_expired(temp_refresh_token):
+                self._refresh_token = temp_refresh_token
+                self.refresh_token()
             else:
-                create_session_req = CreateSessionRequest(type="native", authToken=auth_tokens_resp.authToken,
-                                                          otpCode=None)
-                session_result = self.client.post("/me/sessions", custom_headers, create_session_req.model_dump())
-
-            create_session_resp = CreateSessionResponse.model_validate(session_result)
-
-            self._access_token = create_session_resp.accessToken
-            self._refresh_token = create_session_resp.refreshToken
+                custom_headers = {CLIENT_ID_HEADER: self._client_id}
+                req = AuthTokenRequest(email=self._email, password=self._password)
+                auth_tokens_result = self.client.post("/me/auth-tokens", custom_headers, req.model_dump())
+
+                if not auth_tokens_result:
+                    logger.error("Login failed: Received empty response from auth-tokens endpoint")
+                    return False
+
+                auth_tokens_resp = AuthTokenResponse.model_validate(auth_tokens_result)
+
+                # Handle 2FA
+                if auth_tokens_resp.is2FARequired:
+                    for attempt in range(3):
+                        code = input(f"Attempt {attempt + 1}/3: Please enter the 2FA code: ")
+                        create_session_req = CreateSessionRequest(
+                            type="native", authToken=auth_tokens_resp.authToken, otpCode=code
+                        )
+                        try:
+                            session_result = self.client.post("/me/sessions", custom_headers,
+                                                            create_session_req.model_dump())
+                            if session_result:
+                                break
+                        except RequestException:
+                            logger.warning("Invalid 2FA code, please try again.")
+                            if attempt == 2:
+                                logger.error("Failed to create session after 3 incorrect 2FA attempts.")
+                                return False
+                else:
+                    create_session_req = CreateSessionRequest(type="native", authToken=auth_tokens_resp.authToken,
+                                                            otpCode=None)
+                    session_result = self.client.post("/me/sessions", custom_headers, create_session_req.model_dump())
+
+                create_session_resp = CreateSessionResponse.model_validate(session_result)
+
+                self._access_token = create_session_resp.accessToken
+                self._refresh_token = create_session_resp.refreshToken
+                # first login write refresh token to system config
+                write_user_refresh_token_to_system_config(self._email,self._refresh_token)
             self._user_id = self.parse_user_id()
 
             # Fetch profile to get organization ID
@@ -96,7 +108,12 @@ class IAMClient:
         """
         try:
             custom_headers = {CLIENT_ID_HEADER: self._client_id}
-            result = self.client.patch("/me/sessions", custom_headers, {"refreshToken": self._refresh_token})
+            try:
+                result = self.client.patch("/me/sessions", custom_headers, {"refreshToken": self._refresh_token})
+            except Exception as err:
+                logger.error(f"{str(err)}, please re-login.")
+                write_user_refresh_token_to_system_config(self._email,"")
+                return False
 
             if not result:
                 logger.error("Failed to refresh token: Empty response received")
@@ -105,7 +122,9 @@ class IAMClient:
             resp = CreateSessionResponse.model_validate(result)
             self._access_token = resp.accessToken
             self._refresh_token = resp.refreshToken
-
+            # the _refresh_token will be updated when call this function
+            # so write it to system config file for update the _refresh_token expired time
+            write_user_refresh_token_to_system_config(self._email,self._refresh_token)
             return True
         except (RequestException, ValueError) as e:
             logger.error(f"Token refresh failed: {e}")

gmicloud/_internal/_client/_video_client.py

@@ -0,0 +1,111 @@
+
+import logging
+from requests.exceptions import RequestException
+
+from ._http_client import HTTPClient
+from ._decorator import handle_refresh_token
+from ._iam_client import IAMClient
+from .._config import IAM_SERVICE_BASE_URL
+from .._models import *
+
+
+logger = logging.getLogger(__name__)
+
+
+class VideoClient:
+    """
+    A client for interacting with the video service API.
+
+    This client provides methods to retrieve, create, update, and stop video tasks
+    through HTTP calls to the video service.
+    """
+
+    def __init__(self, iam_client: IAMClient):
+        """
+        Initializes the VideoClient with the given base URL for the video service.
+        """
+        self.client = HTTPClient(IAM_SERVICE_BASE_URL+ "/ie/requestqueue")
+        self.iam_client = iam_client
+
+
+    @handle_refresh_token
+    def get_request_detail(self, request_id: str) -> GetRequestResponse:
+        """
+        Retrieves detailed information about a specific request by its ID. This endpoint requires authentication with a bearer token and only returns requests belonging to the authenticated organization.
+
+        :param request_id: The ID of the request to be retrieved.
+        :return: Details of the GetRequestResponse successfully retrieved
+        """
+        try:
+            response = self.client.get(f"/requests/{request_id}", self.iam_client.get_custom_headers())
+            return GetRequestResponse.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to retrieve request details for {request_id}: {e}")
+            return None
+
+
+    @handle_refresh_token
+    def get_requests(self, model_id: str) -> List[GetRequestResponse]:
+        """
+        Retrieves a list of requests submitted by the authenticated user for a specific model. This endpoint requires authentication with a bearer token and filters results by the authenticated organization.
+
+        :param model_id: The ID of the model to be retrieved.
+        :return: List of GetRequestResponse successfully retrieved
+        """
+        try:
+            response = self.client.get("/requests", self.iam_client.get_custom_headers(), {"model_id": model_id})
+            requests = response.get('requests', []) if response else []
+            return [GetRequestResponse.model_validate(req) for req in requests] if requests else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to retrieve requests for model {model_id}: {e}")
+            return None
+
+
+    @handle_refresh_token
+    def create_request(self, request: SubmitRequestRequest) -> SubmitRequestResponse:
+        """
+        Submits a new asynchronous request to process a specified model with provided parameters. This endpoint requires authentication with a bearer token.
+
+        :param request: The request data to be created by SubmitRequestRequest model.
+        :return: The created request data as SubmitRequestResponse model.
+        """
+        try:
+            response = self.client.post("/requests", self.iam_client.get_custom_headers(), request.model_dump())
+            return SubmitRequestResponse.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to create request: {e}")
+            return None
+
+
+    @handle_refresh_token
+    def get_model_detail(self, model_id: str) -> GetModelResponse:
+        """
+        Retrieves detailed information about a specific model by its ID.
+
+        :param model_id: The ID of the model to be retrieved.
+        :return: Details of the GetModelResponse model successfully retrieved.
+        """
+        try:
+            response = self.client.get(f"/models/{model_id}", self.iam_client.get_custom_headers())
+            return GetModelResponse.model_validate(response) if response else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to retrieve model details for {model_id}: {e}")
+            return None    
+    
+
+    @handle_refresh_token
+    def get_models(self) -> List[GetModelResponse]:
+        """
+        Retrieves a list of available models from the video service.
+
+        :return: A list of GetModelResponse model successfully retrieved.
+        """
+        try:
+            response = self.client.get("/models", self.iam_client.get_custom_headers())
+            models = response.get('models', []) if response else []
+            return [GetModelResponse.model_validate(model) for model in models] if models else None
+        except (RequestException, ValueError) as e:
+            logger.error(f"Failed to retrieve models: {e}")
+            return None
+    
+

gmicloud/_internal/_enums.py

@@ -24,6 +24,7 @@ class TaskEndpointStatus(str, Enum):
     UNREADY = "unready"
     NEW = "new"
 
+
 class TaskStatus(str, Enum):
     IDLE = "idle"
     STARTING = "starting"
@@ -32,7 +33,24 @@ class TaskStatus(str, Enum):
     NEEDSTOP = "needstop"
     ARCHIVED = "archived"
 
+
 class ModelParameterType(str, Enum):
     NUMERIC = "numeric"
     TEXT = "text"
-    BOOLEAN = "boolean"
+    BOOLEAN = "boolean"
+
+
+class RequestStatus(Enum):
+    CREATED = "created"
+    QUEUED = "queued"
+    DISPATCHED = "dispatched"
+    PROCESSING = "processing"
+    SUCCESS = "success"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class HostType(Enum):
+    DEFAULT = ""
+    INTERNAL = "internal"
+    EXTERNAL = "external"

gmicloud/_internal/_manager/_artifact_manager.py

@@ -1,6 +1,6 @@
 import os
 import time
-from typing import List
+from typing import List, Dict, Any
 import mimetypes
 import concurrent.futures
 import re
@@ -64,6 +64,7 @@ class ArtifactManager:
             env_parameters: Optional[List["EnvParameter"]] = None,
             model_description: Optional[str] = "",
             model_parameters: Optional[List["ModelParameter"]] = None,
+            artifact_volume_path: Optional[str] = "",
     ) -> CreateArtifactResponse:
         """
         Create a new artifact for a user.
@@ -84,7 +85,8 @@ class ArtifactManager:
                                     template_id=template_id,
                                     env_parameters=env_parameters,
                                     model_description=model_description,
-                                    model_parameters=model_parameters)
+                                    model_parameters=model_parameters,
+                                    artifact_volume_path=artifact_volume_path)
 
         return self.artifact_client.create_artifact(req)
 
@@ -146,7 +148,7 @@ class ArtifactManager:
             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]:
+    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 = "", pre_download_model: str = "", env_parameters: Optional[Dict[str, Any]] = None) -> tuple[str, ReplicaResource]:
         """
         Create an artifact from a template and support custom model.
         :param artifact_template_name: The name of the template to use.
@@ -169,7 +171,7 @@ class ArtifactManager:
         
         try:
             if gpu_type not in ["H100", "H200"]:
-                raise ValueError("Only support A100 and H100 for now")
+                raise ValueError("Only support H100 and H200 for now")
             
             type, env_vars, serve_args_dict = parse_server_command(serve_command)
             if type.lower() not in template_name.lower():
@@ -185,11 +187,25 @@ class ArtifactManager:
             raise ValueError(f"Failed to parse serve command, Error: {e}")
 
         try:
-            env_vars = [
+            env_vars = []
+            if picked_template.template_data and picked_template.template_data.env_parameters:
+                env_vars = picked_template.template_data.env_parameters
+            env_vars_map = {param.key: param for param in env_vars}
+            if env_parameters:
+                for key, value in env_parameters.items():
+                    if key in ['GPU_TYPE', 'SERVE_COMMAND']:
+                        continue
+                    if key not in env_vars_map:
+                        new_param = EnvParameter(key=key, value=value)
+                        env_vars.append(new_param)
+                        env_vars_map[key] = new_param
+                    else:
+                        env_vars_map[key].value = value
+            env_vars.extend([
                 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)
+            ])
+            resp = self.create_artifact(artifact_name, artifact_description, deployment_type="template", template_id=picked_template.template_id, env_parameters=env_vars, artifact_volume_path=f"models/{pre_download_model}")
             # Assume Artifact is already with BuildStatus.SUCCESS status
             return resp.artifact_id, recommended_replica_resources
         except Exception as e:
@@ -332,6 +348,9 @@ class ArtifactManager:
         # List all files in the model directory recursively
         model_file_paths = []
         for root, _, files in os.walk(model_directory):
+            # Skip .cache folder
+            if '.cache' in root.split(os.path.sep):
+                continue
             for file in files:
                 model_file_paths.append(os.path.join(root, file))
 
@@ -393,7 +412,7 @@ class ArtifactManager:
                 artifact = self.get_artifact(artifact_id)
                 if artifact.build_status == BuildStatus.SUCCESS:
                     return
-                elif artifact.build_status in [BuildStatus.FAILED, BuildStatus.TIMEOUT, BuildStatus.CANCELLED]:
+                elif artifact.build_status in [BuildStatus.FAILURE, 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}")

gmicloud/_internal/_manager/_task_manager.py

@@ -65,6 +65,24 @@ class TaskManager:
 
         logger.info(f"Task created: {resp.task.task_id}")
         return resp.task
+    
+    def create_task_from_artifact_id(self, artifact_id: str, replica_resource: ReplicaResource, task_scheduling: TaskScheduling) -> Task:
+        """
+        Create a new task using the configuration data from a file.
+        """
+        # Create Task based on Artifact
+        new_task = Task(
+            config=TaskConfig(
+                ray_task_config=RayTaskConfig(
+                    artifact_id=artifact_id,
+                    file_path="serve",
+                    deployment_name="app",
+                    replica_resource=replica_resource,
+                ),
+                task_scheduling = task_scheduling,
+            ),
+        )
+        return self.create_task(new_task).task_id
 
     def create_task_from_file(self, artifact_id: str, config_file_path: str, trigger_timestamp: int = None) -> Task:
         """
@@ -218,6 +236,17 @@ class TaskManager:
                 raise Exception(f"Task stopping takes more than {timeout_s // 60} minutes. Testing aborted.")
             time.sleep(10)
 
+    def get_task_endpoint_url(self, task_id: str) -> str:
+        task = self.get_task(task_id)
+        if task.endpoint_info is not None and task.endpoint_info.endpoint_status == TaskEndpointStatus.RUNNING:
+            return task.endpoint_info.endpoint_url
+        else:
+            if task.cluster_endpoints:
+                for ce in task.cluster_endpoints:
+                    if ce.endpoint_status == TaskEndpointStatus.RUNNING:
+                        return ce.endpoint_url
+            return ""
+
 
     def get_usage_data(self, start_timestamp: str, end_timestamp: str) -> GetUsageDataResponse:
         """

gmicloud/_internal/_manager/_video_manager.py

@@ -0,0 +1,91 @@
+import os
+import logging
+
+from .._client._iam_client import IAMClient
+from .._client._video_client import VideoClient
+from .._models import *
+
+
+logger = logging.getLogger(__name__)
+
+class VideoManager:
+    """
+    A manager for handling video tasks, providing methods to create, update, and stop tasks.
+    """
+
+    def __init__(self, iam_client: IAMClient):
+        """
+        Initializes the VideoManager with the given IAM client.
+        """
+        self.video_client = VideoClient(iam_client)
+        self.iam_client = iam_client
+
+    
+    def get_request_detail(self, request_id: str) -> GetRequestResponse:
+        """
+        Retrieves detailed information about a specific request by its ID. This endpoint requires authentication with a bearer token and only returns requests belonging to the authenticated organization.
+
+        :param request_id: The ID of the request to be retrieved.
+        :return: Details of the request successfully retrieved
+        """
+        self._validate_not_empty(request_id, "request_id")
+        return self.video_client.get_request_detail(request_id)
+
+
+    def get_requests(self, model_id: str) -> List[GetRequestResponse]:
+        """
+        Retrieves a list of requests submitted by the authenticated user for a specific model. This endpoint requires authentication with a bearer token and filters results by the authenticated organization.
+
+        :param model_id: The ID of the model to be retrieved.
+        :return: List of user's requests successfully retrieved
+        """
+        self._validate_not_empty(model_id, "model_id")
+        return self.video_client.get_requests(model_id)
+
+
+    def create_request(self, request: SubmitRequestRequest) -> SubmitRequestResponse:
+        """
+        Submits a new asynchronous request to process a specified model with provided parameters. This endpoint requires authentication with a bearer token.
+
+        :param request: The request data to be created.
+        :return: The created request data.
+        """
+        if not request:
+            raise ValueError("Request data cannot be None.")
+        if not request.model:
+            raise ValueError("Model ID is required in the request data.")
+        if not request.payload:
+            raise ValueError("Payload is required in the request data.")
+        return self.video_client.create_request(request)
+        
+    
+    def get_model_detail(self, model_id: str) -> GetModelResponse:
+        """
+        Retrieves detailed information about a specific model by its ID.
+
+        :param model_id: The ID of the model to be retrieved.
+        :return: Details of the specified model.
+        """
+        self._validate_not_empty(model_id, "model_id")
+        return self.video_client.get_model_detail(model_id)
+
+
+    def get_models(self) -> List[GetModelResponse]:
+        """
+        Retrieves a list of available models for video processing.
+
+        :return: A list of available models.
+        """
+        return self.video_client.get_models()
+
+
+    @staticmethod
+    def _validate_not_empty(value: str, name: str):
+        """
+        Validate a string is neither None nor empty.
+
+        :param value: The string to validate.
+        :param name: The name of the value for error reporting.
+        """
+        if not value or not value.strip():
+            raise ValueError(f"{name} is required and cannot be empty.")

gmicloud/_internal/_manager/serve_command_utils.py

@@ -39,18 +39,21 @@ def parse_flags_and_args(tokens: list) -> dict:
     i = 0
     while i < len(tokens):
         token = tokens[i]
-        if token.startswith('--'):
+        if token.startswith('--') or 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("'\"")
+                if token.startswith('--'):
+                    result[token[2:]] = tokens[i + 1].strip("'\"")
+                else:
+                    result[token[1:]] = tokens[i + 1].strip("'\"")
                 i += 1
             else:
-                result[token[2:]] = True
+                if token.startswith('--'):
+                    result[token[2:]] = True
+                else:
+                    result[token[1:]] = True
         else:
             logger.warning(f"Ignoring unknown token: {token}")
         i += 1
@@ -118,4 +121,5 @@ def extract_gpu_num_from_serve_command(serve_args_dict: dict) -> int:
     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.")
+    print(f'cmd_tp_size: {cmd_tp_size}, cmd_dp_size: {cmd_dp_size}, cmd_gpu_num: {cmd_gpu_num}')
     return cmd_gpu_num

gmicloud/_internal/_models.py

@@ -2,7 +2,7 @@ from typing import Optional, List, Union
 from datetime import datetime
 
 from pydantic import BaseModel
-from gmicloud._internal._enums import BuildStatus, TaskStatus, TaskEndpointStatus, ModelParameterType
+from gmicloud._internal._enums import *
 
 
 class BigFileMetadata(BaseModel):
@@ -103,6 +103,7 @@ class CreateArtifactRequest(BaseModel):
     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.
+    artifact_volume_path: Optional[str] = ""  # Path to the volume where the artifact is stored.
 
 
 class CreateArtifactResponse(BaseModel):
@@ -586,3 +587,85 @@ class GetSelfAPIKeyResponse(BaseModel):
     """
     key: APIKey  # The API key of the current user.
     organization: Optional[Organization] = None  # Organization information.
+
+
+
+# ----------------- video models -----------------
+
+class SubmitRequestRequest(BaseModel):
+    """
+    The request body for submits a new asynchronous request 
+    """
+    model: str
+    payload: dict
+
+
+class SubmitRequestResponse(BaseModel):
+    """
+    Represents the response body for a submitted request.
+    """
+    created_at: Optional[int] = 0
+    model: Optional[str] = ""
+    queued_at: Optional[int] = 0
+    request_id: Optional[str] = ""
+    status: Optional[RequestStatus] = None
+    updated_at: Optional[int] = 0
+
+
+class GetRequestResponse(BaseModel):
+    """
+    Response object for getting a specific request.
+    """
+    created_at: Optional[int] = 0
+    is_public: Optional[bool] = False
+    model: Optional[str] = ""
+    org_id: Optional[str] = ""
+    outcome: Optional[dict] = {}
+    payload: Optional[dict] = {}
+    queued_at: Optional[int] = 0
+    qworker_id: Optional[str] = ""
+    request_id: Optional[str] = ""
+    status: Optional[RequestStatus] = None
+    updated_at: Optional[int] = 0
+
+
+class ListUserRequestsResponse(BaseModel):
+    """
+    Represents the response body for listing user requests.
+    """
+    requests: List[GetRequestResponse]
+    total: Optional[int] = 0  # Total number of requests available for the user.
+
+
+class PriceInfo(BaseModel):
+    """
+    Represents pricing information for a model.
+    """
+    price: Optional[int] = 0
+    pricing_type: Optional[str] = ""
+    unit: Optional[str] = ""
+
+
+class GetModelResponse(BaseModel):
+    """
+    Represents the response body for a specific model.
+    """
+    background_image_url: Optional[str] = ""
+    brief_description: Optional[str] = ""
+    created_at: Optional[int] = 0
+    detailed_description: Optional[str] = ""
+    external_api_endpoint: Optional[str] = ""
+    external_api_url: Optional[str] = ""
+    external_provider: Optional[str] = ""
+    host_type: Optional[HostType] = HostType.DEFAULT
+    icon_link: Optional[str] = ""
+    internal_parameters: Optional[dict] = {}
+    modalities: Optional[dict] = {}
+    model: Optional[str] = ""
+    model_type: Optional[str] = ""
+    org_id: Optional[str] = ""
+    parameters: Optional[list] = []
+    price_info: Optional[PriceInfo] = None
+    qworkers: Optional[int] = 0
+    tags: Optional[list[str]] = []
+    updated_at: Optional[int] = 0

gmicloud/client.py

@@ -8,6 +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._manager._video_manager import VideoManager
 from ._internal._enums import BuildStatus, TaskStatus, TaskEndpointStatus
 from ._internal._models import Task, TaskConfig, RayTaskConfig, TaskScheduling, ReplicaResource
 
@@ -37,6 +38,7 @@ class Client:
         self._artifact_manager = None
         self._task_manager = None
         self._iam_manager = None
+        self._video_manager = None
 
     @property
     def artifact_manager(self):
@@ -58,6 +60,16 @@ class Client:
             self._task_manager = TaskManager(self.iam_client)
         return self._task_manager
 
+    @property
+    def video_manager(self):
+        """
+        Lazy initialization for VideoManager.
+        Ensures the Client instance controls its lifecycle.
+        """
+        if self._video_manager is None:
+            self._video_manager = VideoManager(self.iam_client)
+        return self._video_manager
+
     @property
     def iam_manager(self):
         """

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gmicloud
-Version: 0.1.7
+Version: 0.1.9
 Summary: GMI Cloud Python SDK
 Author-email: GMI <gmi@gmitec.net>
 License: MIT
@@ -133,7 +133,22 @@ 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
+#### Pre-downloaded models
+```
+"deepseek-ai/DeepSeek-R1"
+"deepseek-ai/DeepSeek-V3-0324"
+"deepseek-ai/DeepSeek-R1-Distill-Llama-70B"
+"deepseek-ai/DeepSeek-R1-Distill-Llama-8B"
+"deepseek-ai/DeepSeek-R1-Distill-Qwen-14B"
+"deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
+"deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"
+"meta-llama/Llama-3.3-70B-Instruct"
+"meta-llama/Llama-4-Maverick-17B-128E-Instruct"
+"meta-llama/Llama-4-Scout-17B-16E-Instruct"
+"Qwen/QwQ-32B"
+```
+
+2. Find a template of specific vllm or SGLang version
 
 ```python
 # export GMI_CLOUD_CLIENT_ID=<YOUR_CLIENT_ID>
@@ -158,55 +173,67 @@ 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
+4. Create an artifact. you can pass `pre_download_model` parameter. If you want custom model, upload model checkpoint to the artifactThe 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",
-    }
+artifact_name = "artifact_hello_world"
+artifact_id, recommended_replica_resources = cli.artifact_manager.create_artifact_for_serve_command_and_custom_model(
+    template_name=picked_template_name,
+    artifact_name=artifact_name,
+    serve_command=serve_command,
+    gpu_type="H100",
+    artifact_description="This is a test artifact",
+    pre_download_model=pick_pre_downloaded_model,
 )
 print(f"Created artifact {artifact_id} with recommended resources: {recommended_replica_resources}")
+```
 
-# Upload model files to artifact
+Alternatively, Upload a custom model checkpoint to artifact
+```python
 cli.artifact_manager.upload_model_files_to_artifact(artifact_id, model_checkpoint_save_dir)
+
+# Maybe Wait 10 minutes for the artifact to be ready
+time.sleep(10 * 60)
 ```
 
 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)
+# Create Task based on Artifact
+new_task_id = cli.task_manager.create_task_from_artifact_id(artifact_id, recommended_replica_resources, TaskScheduling(
+    scheduling_oneoff=OneOffScheduling(
+        trigger_timestamp=int(datetime.now().timestamp()),
+        min_replicas=1,
+        max_replicas=4,
+    )
+))
+task = cli.task_manager.get_task(new_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)
+cli.task_manager.start_task_and_wait(new_task_id)
 ```
 
-6. Test with sample chat completion request
+6. Test with sample chat completion request with OpenAI client
 
 ```python
-print(call_chat_completion(cli, task_id))
+pi_key = "<YOUR_API_KEY>"
+endpoint_url = cli.task_manager.get_task_endpoint_url(new_task_id)
+open_ai = OpenAI(
+    base_url=os.getenv("OPENAI_API_BASE", f"https://{endpoint_url}/serve/v1/"),
+    api_key=api_key
+)
+# Make a chat completion request using the new OpenAI client.
+completion = open_ai.chat.completions.create(
+    model=picked_template_name,
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Who are you?"},
+    ],
+    max_tokens=500,
+    temperature=0.7
+)
+print(completion.choices[0].message.content)
 ```
 
 

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

@@ -1,28 +1,31 @@
 gmicloud/__init__.py,sha256=xSzrAxiby5Te20yhy1ZylGHmQKVV_w1QjFe6D99VZxw,968
-gmicloud/client.py,sha256=G0tD0xQnpqDKS-3l-AAU-K3FAHOsqsTzsAq2NVxiamY,10539
+gmicloud/client.py,sha256=nTMrKhyrGSx9qUDTice2HqmIqlIlsuKoxHnb0T-Ls3c,10947
 gmicloud/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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/_enums.py,sha256=aN3At0_iV_6aaUsrOy-JThtRUokeY4nTyxxPLZmIDBU,1093
 gmicloud/_internal/_exceptions.py,sha256=hScBq7n2fOit4_umlkabZJchY8zVbWSRfWM2Y0rLCbw,306
-gmicloud/_internal/_models.py,sha256=2l65aZdQxyXlY0Dj23P6NFf59_zopgf9OoUMLAz5T2U,22685
+gmicloud/_internal/_models.py,sha256=iSRHMUPx_iXEraSg3ouAIM4ipVXQop3MuCGJFvFvMLY,25011
 gmicloud/_internal/_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gmicloud/_internal/_client/_artifact_client.py,sha256=0lyHAdUybN8A1mEwZ7p1yK2yQEyoDG2vTB4Qe5RI2ik,9974
+gmicloud/_internal/_client/_auth_config.py,sha256=zlCUPHN_FgWmOAxOAgjBtGRbaChqMa9PPGPuVNKvnc8,2700
 gmicloud/_internal/_client/_decorator.py,sha256=sy4gxzsUB6ORXHw5pqmMf7TTlK41Nmu1fhIhK2AIsbY,670
 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/_iam_client.py,sha256=iXam-UlTCJWCpXmxAhqCo0J2m6nPzNOWa06R5xAy5nQ,8297
 gmicloud/_internal/_client/_task_client.py,sha256=69OqZC_kwSDkTSVVyi51Tn_OyUV6R0nin4z4gLfZ-Lg,6141
+gmicloud/_internal/_client/_video_client.py,sha256=bjSmChBydGXwuVIm37ltKGmduPJa-H0Bjyc-qhd_PZI,4694
 gmicloud/_internal/_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gmicloud/_internal/_manager/_artifact_manager.py,sha256=yK4veVwCY1cipy3rdnGvhnKNvkBx3SYYpHKqzjtXJn0,20731
+gmicloud/_internal/_manager/_artifact_manager.py,sha256=Fq5Qifrdq5yn_QkMAoykuWE04FgqNOd9yZrFQdAi5J8,21874
 gmicloud/_internal/_manager/_iam_manager.py,sha256=nAqPCaUfSXTnx2MEQa8e0YUOBFYWDRiETgK1PImdf4o,1167
-gmicloud/_internal/_manager/_task_manager.py,sha256=zBW_TkYhbSvAc_p7Q3z6Vgl2Cayv8zIkawTT6OcB4x4,11291
-gmicloud/_internal/_manager/serve_command_utils.py,sha256=xjB6B9CNAmohou41H755iCCgkLNrjvdnu9NcJApTm1k,4373
+gmicloud/_internal/_manager/_task_manager.py,sha256=g2K0IG1EXzcZRAfXLhUp78em0ZVvKyqlr1PGTBR04JQ,12501
+gmicloud/_internal/_manager/_video_manager.py,sha256=_PwooKf9sZkIx4mYTy57pXtP7J3uwHQHgscns5hQYZ0,3376
+gmicloud/_internal/_manager/serve_command_utils.py,sha256=0PXDRuGbLw_43KBwCxPRdb4QqijZrzYyvM6WOZ2-Ktg,4583
 gmicloud/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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.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.9.dist-info/METADATA,sha256=sZlrvpl2xiwBoVJj79IQ0JIFXg8md9mCmA13P99dXj0,9028
+gmicloud-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gmicloud-0.1.9.dist-info/top_level.txt,sha256=AZimLw3y0WPpLiSiOidZ1gD0dxALh-jQNk4fxC05hYE,9
+gmicloud-0.1.9.dist-info/RECORD,,

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

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