gmicloud 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

gmicloud/__init__.py

@@ -12,7 +12,8 @@ from ._internal._models import (
     OneOffScheduling,
     DailyScheduling,
     DailyTrigger,
-    ArtifactTemplate
+    ArtifactTemplate,
+    CreateArtifactFromTemplateResponse
 )
 from ._internal._enums import (
     BuildStatus,
@@ -37,5 +38,6 @@ __all__ = [
     "DailyTrigger",
     "ArtifactTemplate",
     "BuildStatus",
-    "TaskEndpointStatus"
+    "TaskEndpointStatus",
+    "CreateArtifactFromTemplateResponse"
 ]

gmicloud/_internal/_client/_artifact_client.py

@@ -42,11 +42,10 @@ class ArtifactClient:
         return Artifact.model_validate(result)
 
     @handle_refresh_token
-    def get_all_artifacts(self, user_id: str) -> List[Artifact]:
+    def get_all_artifacts(self) -> List[Artifact]:
         """
-        Fetches all artifacts for a given user ID.
+        Fetches all artifacts.
 
-        :param user_id: The ID of the user whose artifacts are being fetched.
         :return: A list of Artifact objects.
         :rtype: List[Artifact]
         """
@@ -54,7 +53,7 @@ class ArtifactClient:
             ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
             CLIENT_ID_HEADER: self.iam_client.get_client_id()
         }
-        result = self.client.get("/get_all_artifacts", custom_headers, {"user_id": user_id})
+        result = self.client.get("/get_all_artifacts", custom_headers)
         if not result:
             return []
         return [Artifact.model_validate(item) for item in result]
@@ -77,12 +76,11 @@ class ArtifactClient:
         return CreateArtifactResponse.model_validate(result)
 
     @handle_refresh_token
-    def create_artifact_from_template(self,
-                                      request: CreateArtifactFromTemplateRequest) -> CreateArtifactFromTemplateResponse:
+    def create_artifact_from_template(self, artifact_template_id: str) -> CreateArtifactFromTemplateResponse:
         """
         Creates a new artifact in the service.
 
-        :param request: The request object containing artifact details.
+        :param artifact_template_id: The ID of the artifact template to use.
         :return: The response object containing the created artifact details.
         :rtype: CreateArtifactFromTemplateResponse
         """
@@ -91,7 +89,7 @@ class ArtifactClient:
             CLIENT_ID_HEADER: self.iam_client.get_client_id()
         }
         result = self.client.post("/create_artifact_from_template", custom_headers,
-                                  request.model_dump())
+                                  {"artifact_template_id": artifact_template_id})
 
         return CreateArtifactFromTemplateResponse.model_validate(result)
 

gmicloud/_internal/_client/_http_client.py

@@ -39,7 +39,6 @@ class HTTPClient:
         :return: The JSON response parsed as a Python dictionary.
         :raises APIError: If the request fails or the response is invalid.
         """
-        print("data=", data)
         url = self._prepare_url(endpoint)
         headers = {
             ACCEPT_HEADER: JSON_CONTENT_TYPE,
@@ -52,21 +51,7 @@ class HTTPClient:
 
         response = None
         try:
-            # if method == HTTP_METHOD_POST:
-            #     response = requests.post(url, json=data, headers=headers)
-            # elif method == HTTP_METHOD_GET:
-            #     response = requests.get(url, params=params, headers=headers)
-            # elif method == HTTP_METHOD_PATCH:
-            #     response = requests.patch(url, data=data, headers=headers)
-            # elif method == HTTP_METHOD_DELETE:
-            #     response = requests.delete(url, params=params, headers=headers)
-            # else:
-            #     raise APIError(f"Unsupported HTTP method: {method}")
             response = requests.request(method, url, params=params, json=data, headers=headers)
-            # response = method_map[method](url, json=data if method != HTTP_METHOD_GET else None,
-            #                               params=params, headers=headers)
-
-            print("=============", response.text)
             if response.status_code == 401:
                 raise UnauthorizedError("Access token expired or invalid.")
             elif response.status_code != 200 and response.status_code != 201:

gmicloud/_internal/_client/_task_client.py

@@ -39,7 +39,7 @@ class TaskClient:
         return Task.model_validate(result)
 
     @handle_refresh_token
-    def get_all_tasks(self, user_id: str) -> GetAllTasksResponse:
+    def get_all_tasks(self) -> GetAllTasksResponse:
         """
         Retrieves all tasks from the task service.
 
@@ -50,7 +50,7 @@ class TaskClient:
             ACCESS_TOKEN_HEADER: self.iam_client.get_access_token(),
             CLIENT_ID_HEADER: self.iam_client.get_client_id()
         }
-        result = self.client.get("/get_tasks", custom_headers, {"user_id": user_id})
+        result = self.client.get("/get_tasks", custom_headers)
         if not result:
             return GetAllTasksResponse(tasks=[])
 

gmicloud/_internal/_manager/_artifact_manager.py

@@ -43,7 +43,7 @@ class ArtifactManager:
         :return: A list of Artifact objects associated with the user.
         :rtype: List[Artifact]
         """
-        return self.artifact_client.get_all_artifacts(self.iam_client.get_user_id())
+        return self.artifact_client.get_all_artifacts()
 
     def create_artifact(
             self,
@@ -63,27 +63,25 @@ class ArtifactManager:
         if not artifact_name or not artifact_name.strip():
             raise ValueError("Artifact name is required and cannot be empty.")
 
-        req = CreateArtifactRequest(user_id=self.iam_client.get_user_id(), artifact_name=artifact_name,
+        req = CreateArtifactRequest(artifact_name=artifact_name,
                                     artifact_description=description,
                                     artifact_tags=tags, )
 
         return self.artifact_client.create_artifact(req)
 
-    def create_artifact_from_template(self, artifact_template_id: str) -> CreateArtifactFromTemplateResponse:
+    def create_artifact_from_template(self, artifact_template_id: str) -> str:
         """
         Create a new artifact for a user using a template.
 
         :param artifact_template_id: The ID of the template to use for the artifact.
-        :return: A `CreateArtifactResponse` object containing information about the created artifact.
-        :rtype: CreateArtifactResponse
+        :return: The `artifact_id` of the created artifact.
+        :rtype: str
+        :raises ValueError: If `artifact_template_id` is None or empty.
         """
         if not artifact_template_id or not artifact_template_id.strip():
             raise ValueError("Artifact template ID is required and cannot be empty.")
 
-        req = CreateArtifactFromTemplateRequest(user_id=self.iam_client.get_user_id(),
-                                                artifact_template_id=artifact_template_id)
-
-        return self.artifact_client.create_artifact_from_template(req)
+        return self.artifact_client.create_artifact_from_template(artifact_template_id).artifact_id
 
     def rebuild_artifact(self, artifact_id: str) -> RebuildArtifactResponse:
         """

gmicloud/_internal/_manager/_task_manager.py

@@ -106,7 +106,6 @@ class TaskManager:
         self._validate_file_path(config_file_path)
 
         task = self._read_file_and_parse_task(config_file_path)
-        print("================", task)
         task.task_id = task_id
         task.config.ray_task_config.artifact_id = artifact_id
 
@@ -213,7 +212,6 @@ class TaskManager:
             file_data = file.read()
 
         try:
-            print("!!!!!!!!!!!1", file_data)
             task = Task.model_validate_json(file_data)  # Ensure Task has a static method for model validation.
         except Exception as e:
             raise ValueError(f"Failed to parse Task from file: {file_path}. Error: {str(e)}")

gmicloud/_internal/_models.py

@@ -66,7 +66,6 @@ class CreateArtifactRequest(BaseModel):
     """
     Request object to create a new artifact.
     """
-    user_id: str  # The user ID creating the artifact.
     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.
@@ -146,6 +145,20 @@ class ArtifactTemplate(BaseModel):
     artifact_description: Optional[str] = ""  # Description of the artifact template.
     artifact_name: Optional[str] = ""  # Name of the artifact template.
     artifact_tags: Optional[List[str]] = None  # Tags associated with the artifact template.
+    ray: Optional["RayTemplate"] = None  # Template for Ray-based artifacts.
+    resources: Optional["ResourcesTemplate"] = None  # Resource allocation template.
+
+
+class RayTemplate(BaseModel):
+    deployment_name: Optional[str] = ""  # Name of the deployment.
+    file_path: Optional[str] = ""  # Path to the task file in storage.
+    version: Optional[str] = ""  # Version of Ray used.
+
+
+class ResourcesTemplate(BaseModel):
+    cpu: Optional[int] = 0  # Number of CPU cores allocated.
+    memory: Optional[int] = 0  # Amount of RAM (in GB) allocated.
+    gpu: Optional[int] = 0  # Number of GPUs allocated.
 
 
 class CreateArtifactFromTemplateRequest(BaseModel):

gmicloud/client.py

@@ -1,10 +1,13 @@
 import os
+import time
 
 from typing import Optional
 
 from ._internal._client._iam_client import IAMClient
 from ._internal._manager._artifact_manager import ArtifactManager
 from ._internal._manager._task_manager import TaskManager
+from ._internal._enums import BuildStatus
+from ._internal._models import Task, TaskConfig, RayTaskConfig, TaskScheduling, OneOffScheduling, ReplicaResource
 
 
 class Client:
@@ -30,6 +33,74 @@ class Client:
         self._artifact_manager = None
         self._task_manager = None
 
+    def create_task_from_artifact_template(self, artifact_template_id: str, task_scheduling: TaskScheduling) -> Task:
+        """
+        Create a task from a template.
+
+        :param artifact_template_id: The ID of the artifact template to use.
+        :param task_scheduling: The scheduling configuration for the task.
+        :return: A `Task` object containing the details of the created task.
+        :rtype: Task
+        """
+        if not artifact_template_id or not artifact_template_id.strip():
+            raise ValueError("Artifact Template ID must be provided.")
+        if not task_scheduling:
+            raise ValueError("Task Scheduling must be provided.")
+
+        artifact_manager = self.artifact_manager
+        task_manager = self.task_manager
+
+        templates = artifact_manager.get_artifact_templates()
+        template = None
+        for v in templates:
+            if v.artifact_template_id == artifact_template_id:
+                template = v
+        if not template:
+            raise ValueError(f"Template with ID {artifact_template_id} not found.")
+        if not template.ray:
+            raise ValueError("Template does not contain Ray configuration.")
+        if not template.resources:
+            raise ValueError("Template does not contain resource configuration.")
+
+        artifact_id = artifact_manager.create_artifact_from_template(artifact_template_id)
+        # Wait for the artifact to be ready
+        while True:
+            try:
+                artifact = artifact_manager.get_artifact(artifact_id)
+                print(f"Artifact status: {artifact.build_status}")
+                # Wait until the artifact is ready
+                if artifact.build_status == BuildStatus.SUCCESS:
+                    break
+            except Exception as e:
+                raise e
+            # Wait for 2 seconds
+            time.sleep(2)
+        try:
+            # Create a task
+            task = task_manager.create_task(Task(
+                config=TaskConfig(
+                    ray_task_config=RayTaskConfig(
+                        ray_version=template.ray.version,
+                        file_path=template.ray.file_path,
+                        artifact_id=artifact_id,
+                        deployment_name=template.ray.deployment_name,
+                        replica_resource=ReplicaResource(
+                            cpu=template.resources.cpu,
+                            ram_gb=template.resources.memory,
+                            gpu=template.resources.gpu,
+                        ),
+                    ),
+                    task_scheduling=task_scheduling,
+                ),
+            ))
+
+            # Start the task
+            task_manager.start_task(task.task_id)
+        except Exception as e:
+            raise e
+
+        return task
+
     @property
     def artifact_manager(self):
         """

gmicloud/tests/test_artifacts.py

@@ -105,7 +105,7 @@ class TestArtifactManager(unittest.TestCase):
                                                                                              status="success")
         artifact_template_id = "template123"
         response = self.artifact_manager.create_artifact_from_template(artifact_template_id)
-        self.assertEqual(response.artifact_id, "1")
+        self.assertEqual(response, "1")
 
     @patch('gmicloud._internal._client._artifact_client.ArtifactClient.create_artifact_from_template')
     def test_create_artifact_from_template_raises_error_for_invalid_template_id(self,

gmicloud/utils/uninstall_packages.py

@@ -0,0 +1,39 @@
+import subprocess
+
+
+def get_installed_packages():
+    """
+    Get a list of currently installed packages using pip freeze.
+    """
+    result = subprocess.run(['pip', 'freeze'], capture_output=True, text=True)
+    return set(result.stdout.splitlines())
+
+
+def get_required_packages(file_path):
+    """
+    Get a list of required packages from the requirements file.
+    """
+    with open(file_path, 'r') as file:
+        return {line.strip() for line in file}
+
+
+def uninstall_packages(packages):
+    """
+    Uninstall the given packages using pip.
+    """
+    for package in packages:
+        subprocess.run(['pip', 'uninstall', '-y', package])
+
+
+if __name__ == '__main__':
+    # Get the list of installed packages
+    installed_packages = get_installed_packages()
+
+    # Get the list of required packages from the requirements file
+    required_packages = get_required_packages('../../requirements.txt')
+
+    # Determine the packages that need to be uninstalled
+    packages_to_uninstall = installed_packages - required_packages
+
+    # Uninstall the packages that are not required
+    uninstall_packages(packages_to_uninstall)

gmicloud-0.1.1.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.2
+Name: gmicloud
+Version: 0.1.1
+Summary: GMI Cloud Python SDK
+Author-email: GMI <gmi@gmitec.net>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# GMICloud SDK
+
+## Overview
+
+The GMI Inference Engine SDK provides a Python interface for deploying and managing machine learning models in
+production environments. It allows users to create model artifacts, schedule tasks for serving models, and call
+inference APIs easily.
+
+This SDK streamlines the process of utilizing GMI Cloud capabilities such as deploying models with Kubernetes-based Ray
+services, managing resources automatically, and accessing model inference endpoints. With minimal setup, developers can
+focus on building ML solutions instead of infrastructure.
+
+## Features
+
+- Artifact Management: Easily create, update, and manage ML model artifacts.
+- Task Management: Quickly create, schedule, and manage deployment tasks for model inference.
+- Usage Data Retrieval : Fetch and analyze usage data to optimize resource allocation.
+
+## Installation
+
+To install the SDK, use pip:
+
+```bash
+pip install gmicloud
+```
+
+## Setup
+
+You must configure authentication credentials for accessing the GMI Cloud API. There are two ways to configure the SDK:
+
+### Option 1: Using Environment Variables
+
+Set the following environment variables:
+
+```shell
+export GMI_CLOUD_CLIENT_ID=<YOUR_CLIENT_ID>
+export GMI_CLOUD_EMAIL=<YOUR_EMAIL>
+export GMI_CLOUD_PASSWORD=<YOUR_PASSWORD>
+```
+
+### Option 2: Passing Credentials as Parameters
+
+Pass `client_id`, `email`, and `password` directly to the Client object when initializing it in your script:
+
+```python
+from gmicloud import Client
+
+client = Client(client_id="<YOUR_CLIENT_ID>", email="<YOUR_EMAIL>", password="<YOUR_PASSWORD>")
+```
+
+## Quick Start
+
+### 1. Create a Task from an Artifact Template
+
+This is the simplest example to deploy an existing artifact template:
+
+```python
+from datetime import datetime
+from gmicloud import Client, TaskScheduling, OneOffScheduling
+from examples.completion import call_chat_completion
+
+# Initialize the client
+client = Client()
+
+# Schedule and start a task from an artifact template
+task = client.create_task_from_artifact_template(
+    "llama31_8b_template_001",
+    TaskScheduling(
+        scheduling_oneoff=OneOffScheduling(
+            trigger_timestamp=int(datetime.now().timestamp()) + 60,  # Delay by 1 min
+            min_replicas=1,
+            max_replicas=10,
+        )
+    )
+)
+
+# Make a chat completion request via the task endpoint
+response = call_chat_completion(client, task.task_id)
+print(response)
+```
+
+### 2. Step-by-Step Example: Create Artifact, Task, and Query the Endpoint
+
+#### (a) Create an Artifact from a Template
+
+First, you’ll retrieve all templates and create an artifact based on the desired template (e.g., "Llama3.1 8B"):
+
+```python
+def create_artifact_from_template(client):
+    artifact_manager = client.artifact_manager
+
+    # List all available templates
+    templates = artifact_manager.get_artifact_templates()
+    for template in templates:
+        if template.artifact_name == "Llama3.1 8B":
+            return artifact_manager.create_artifact_from_template(
+                artifact_template_id=template.artifact_template_id
+            )
+    return None
+```
+
+#### (b) Create a Task from the Artifact
+
+Wait until the artifact becomes "ready" and then deploy it using task scheduling:
+
+```python
+def create_task_and_start(client, artifact_id):
+    artifact_manager = client.artifact_manager
+
+    # Wait until the artifact is ready
+    while True:
+        artifact = artifact_manager.get_artifact(artifact_id)
+        if artifact.build_status == "SUCCESS":
+            break
+        print("Waiting for artifact to be ready...")
+        time.sleep(2)
+
+    # Configure and start the task
+    task_manager = client.task_manager
+    task = task_manager.create_task(Task(
+        config=TaskConfig(
+            ray_task_config=RayTaskConfig(
+                ray_version="latest-py311-gpu",
+                file_path="serve",
+                artifact_id=artifact_id,
+                deployment_name="app",
+                replica_resource=ReplicaResource(
+                    cpu=24,
+                    ram_gb=128,
+                    gpu=2,
+                ),
+            ),
+            task_scheduling=TaskScheduling(
+                scheduling_oneoff=OneOffScheduling(
+                    trigger_timestamp=int(datetime.now().timestamp()) + 60,
+                    min_replicas=1,
+                    max_replicas=10,
+                )
+            ),
+        ),
+    ))
+
+    task_manager.start_task(task.task_id)
+    return task.task_id
+```
+
+### (c) Query the Model Endpoint
+
+Once the task is ready, use the endpoint for inference:
+
+```python
+from examples.completion import call_chat_completion
+
+client = Client()
+artifact_id = create_artifact_from_template(client)
+task_id = create_task_and_start(client, artifact_id)
+
+response = call_chat_completion(client, task_id)
+print(response)
+```
+
+## API Reference
+
+### Client
+
+Represents the entry point to interact with GMI Cloud APIs.
+Client(
+client_id: Optional[str] = "",
+email: Optional[str] = "",
+password: Optional[str] = ""
+)
+
+### Artifact Management
+
+* get_artifact_templates(): Fetch a list of available artifact templates.
+* create_artifact_from_template(template_id: str): Create a model artifact from a given template.
+* get_artifact(artifact_id: str): Get details of a specific artifact.
+
+### Task Management
+
+* create_task_from_artifact_template(template_id: str, scheduling: TaskScheduling): Create and schedule a task using an
+  artifact template.
+* start_task(task_id: str): Start a task.
+* get_task(task_id: str): Retrieve the status and details of a specific task.
+
+## Notes & Troubleshooting
+
+Ensure Credentials are Correct: Double-check your environment variables or parameters passed into the Client object.
+Artifact Status: It may take a few minutes for an artifact or task to transition to the "ready" state.
+Inference Endpoint Readiness: Use the task endpoint only after the task status changes to "ready".
+Default OpenAI Key: By default, the OpenAI API base URL is derived from the endpoint provided by GMI.
+
+## Contributing
+
+We welcome contributions to enhance the SDK. Please follow these steps:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bugfix.
+3. Commit changes with clear messages.
+4. Submit a pull request for review.

gmicloud-0.1.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+gmicloud/__init__.py,sha256=jIefHqO_DemXBs6qR9cTtXsuHAEBQo0INuKZKEl3mW8,822
+gmicloud/client.py,sha256=qgN6Pcoa_dRwBWRy463yW3Nne52d_D8ogdEODH7LGp4,4751
+gmicloud/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gmicloud/_internal/_config.py,sha256=qIH76TSyS3MQWe62LHI46RJhDnklNFisdajY75oUAqE,218
+gmicloud/_internal/_constants.py,sha256=EyhjJp_mEIsAuopFyfnRzGRVjQH9jOhU5AQvtBF_IeU,339
+gmicloud/_internal/_enums.py,sha256=1xGle0FARJEQWkphjUM6yJ1hCqD9YKsh8_5GfkGEvio,477
+gmicloud/_internal/_exceptions.py,sha256=hScBq7n2fOit4_umlkabZJchY8zVbWSRfWM2Y0rLCbw,306
+gmicloud/_internal/_models.py,sha256=tqPiqVktwCtHaldi4imzmQVi7zpjKPCi9O8c6QN2Zn8,13083
+gmicloud/_internal/_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gmicloud/_internal/_client/_artifact_client.py,sha256=V8q78L1wys0d2GYJ87m2EFsLUOJG7nsJvAkrHBeXVU8,6895
+gmicloud/_internal/_client/_decorator.py,sha256=sy4gxzsUB6ORXHw5pqmMf7TTlK41Nmu1fhIhK2AIsbY,670
+gmicloud/_internal/_client/_file_upload_client.py,sha256=1JRs4X57S3EScPIP9w2DC1Uo6_Wbcjumcw3nVM7uIGM,4667
+gmicloud/_internal/_client/_http_client.py,sha256=6xvzYp-pFcKV9U2nOcMKkWpOi3NB_zfWx-bMfsGQwQY,5672
+gmicloud/_internal/_client/_iam_client.py,sha256=57KHyGg_0Vj5AzwhIto0kmbqQYxnixKIOilNO8hCwr0,2698
+gmicloud/_internal/_client/_task_client.py,sha256=G0MqsNDHhdL885jo-isuu9H_Pv_6DLimN7lT-gz2Uv4,5074
+gmicloud/_internal/_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gmicloud/_internal/_manager/_artifact_manager.py,sha256=cc367Kd-W9Zn2d_wUcG6tT06544HRItIZ5IsFfA5_RQ,12201
+gmicloud/_internal/_manager/_task_manager.py,sha256=QQfpYXFKAAI_FSI--Nxvjlgf_jeVZuVnTuRGTQzrZso,8034
+gmicloud/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gmicloud/tests/test_artifacts.py,sha256=YiC1HBMS7g491Ra4acTLI9AdwyjXZfnY9f-fNKn2azQ,17108
+gmicloud/tests/test_tasks.py,sha256=AY90zTJdsXk1cxn6Jxhi4TDdwXRiGxz_r_aRk_Jkl8Y,10956
+gmicloud/utils/uninstall_packages.py,sha256=zzuuaJPf39oTXWZ_7tUAGseoxocuCbbkoglJSD5yDrE,1127
+gmicloud-0.1.1.dist-info/METADATA,sha256=VtHBj-gOFzBp-4aMRKibO13UAK7wX8Rc71xtXi6fVvs,6583
+gmicloud-0.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+gmicloud-0.1.1.dist-info/top_level.txt,sha256=AZimLw3y0WPpLiSiOidZ1gD0dxALh-jQNk4fxC05hYE,9
+gmicloud-0.1.1.dist-info/RECORD,,

{gmicloud-0.1.0.dist-info → gmicloud-0.1.1.dist-info}/top_level.txt

@@ -1,2 +1 @@
-examples
 gmicloud

examples/example.py

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

gmicloud-0.1.0.dist-info/METADATA

@@ -1,208 +0,0 @@
-Metadata-Version: 2.2
-Name: gmicloud
-Version: 0.1.0
-Summary: GMI Cloud Python SDK
-Home-page: https://github.com/GMISWE/python-sdk
-Author: GMI
-Author-email: GMI <gmi@gmitec.net>
-License: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Dynamic: author
-Dynamic: home-page
-Dynamic: requires-python
-
-# GMICloud
-
-## Overview
-
-This project is an open-source SDK for interacting with the GMICLOUD platform. It provides functionalities to manage
-artifacts, tasks, and usage data efficiently.
-
-## Features
-
-- Create and manage artifacts
-- Create and manage tasks
-- Fetch usage data
-- Integration with OpenAI for chat completions
-
-## Installation
-
-To install the SDK, use pip:
-
-```bash
-pip install gmicloud-sdk
-```
-
-## Usage
-
-### Initialize the Client
-
-```python
-from gmicloud import Client
-
-client = Client(username="your_username", password="your_password")
-```
-
-### Create an Artifact with a File
-
-```python
-artifact_id = client.artifact_manager.create_artifact_with_file(
-    artifact_name="Llama3.1 8B",
-    artifact_file_path="./files/Llama-3.1-8B-Instruct.zip",
-    description="This is a test artifact",
-    tags=['example', 'test']
-)
-```
-
-### Create an Artifact from a Template
-
-```python
-artifact_id = client.artifact_manager.create_artifact_from_template(
-    artifact_template_id="template_id"
-)
-```
-
-### Create and Start a Task
-
-```python
-task_id = client.task_manager.create_task(Task(
-    config=TaskConfig(
-        ray_task_config=RayTaskConfig(
-            ray_version="2.40.0-py310-gpu",
-            file_path="serve",
-            artifact_id=artifact_id,
-            deployment_name="app",
-            replica_resource=ReplicaResource(
-                cpu=2,
-                ram_gb=128,
-                gpu=2,
-            ),
-        ),
-        task_scheduling=TaskScheduling(
-            scheduling_oneoff=OneOffScheduling(
-                trigger_timestamp=int(datetime.now().timestamp()) + 60,
-                min_replicas=1,
-                max_replicas=10,
-            )
-        ),
-    ),
-))
-
-client.task_manager.start_task(task_id)
-```
-
-### Call Chat Completion
-
-```python
-from openai import OpenAI
-
-task = client.task_manager.get_task(task_id)
-open_ai = OpenAI(
-    api_key="YOUR_API_KEY",
-    base_url=task.info.endpoint
-)
-
-completion = open_ai.chat.completions.create(
-    model="meta-llama/Llama-3.1-8B-Instruct",
-    messages=[
-        {"role": "system", "content": "You are a helpful assistant."},
-        {"role": "user", "content": "Translate the sentences to Chinese"},
-    ],
-    max_tokens=200,
-    temperature=0.7
-)
-
-print(completion.choices[0].message.content)
-```
-
-## Configuration
-
-### One-off Task Configuration
-
-`examples/config/one-off_task.json`:
-
-```json
-{
-  "config": {
-    "ray_task_config": {
-      "ray_version": "2.40.0",
-      "file_path": "serve",
-      "deployment_name": "string",
-      "replica_resource": {
-        "cpu": 2,
-        "ram_gb": 12,
-        "gpu": 1
-      }
-    },
-    "task_scheduling": {
-      "scheduling_oneoff": {
-        "min_replicas": 1,
-        "max_replicas": 1
-      }
-    }
-  }
-}
-```
-
-### Daily Task Configuration
-
-`examples/config/daily_task.json`:
-
-```json
-{
-  "config": {
-    "ray_task_config": {
-      "ray_version": "2.40.0-py310-gpu",
-      "file_path": "serve",
-      "deployment_name": "string",
-      "replica_resource": {
-        "cpu": 6,
-        "ram_gb": 64,
-        "gpu": 2
-      }
-    },
-    "task_scheduling": {
-      "scheduling_daily": {
-        "triggers": [
-          {
-            "timezone": "UTC",
-            "Hour": 0,
-            "minute": 10,
-            "second": 0,
-            "min_replicas": 1,
-            "max_replicas": 2
-          },
-          {
-            "timezone": "UTC",
-            "Hour": 0,
-            "minute": 10,
-            "second": 30,
-            "min_replicas": 1,
-            "max_replicas": 4
-          }
-        ]
-      }
-    }
-  }
-}
-```
-
-## Running Tests
-
-To run the unit tests, use the following command:
-
-```bash
-pytest
-```
-
-## Contributing
-
-Contributions are welcome! Please open an issue or submit a pull request.
-
-## License
-
-This project is licensed under the MIT License. See the `LICENSE` file for details.

gmicloud-0.1.0.dist-info/RECORD

@@ -1,27 +0,0 @@
-examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-examples/example.py,sha256=VX0EQoLshF2bOm1eDCcrnA-9t3ZPUffKdSMUBVax_UM,4446
-gmicloud/__init__.py,sha256=nvdQUQfy6KxeVU889VKyJjz9iXfShVHKb65rNfyIPlQ,740
-gmicloud/client.py,sha256=D6wPXutlr3hWaFF_3azmYk5kMrvLSObvubDOe29mKfk,1775
-gmicloud/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gmicloud/_internal/_config.py,sha256=qIH76TSyS3MQWe62LHI46RJhDnklNFisdajY75oUAqE,218
-gmicloud/_internal/_constants.py,sha256=EyhjJp_mEIsAuopFyfnRzGRVjQH9jOhU5AQvtBF_IeU,339
-gmicloud/_internal/_enums.py,sha256=1xGle0FARJEQWkphjUM6yJ1hCqD9YKsh8_5GfkGEvio,477
-gmicloud/_internal/_exceptions.py,sha256=hScBq7n2fOit4_umlkabZJchY8zVbWSRfWM2Y0rLCbw,306
-gmicloud/_internal/_models.py,sha256=n8lHes_o3BzpHqS2ZL96OZ1HuaQRD7c1qqTvlHetYpg,12529
-gmicloud/_internal/_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gmicloud/_internal/_client/_artifact_client.py,sha256=IY3CZzcDUg7bM8-UwogF5n7Tb2gWQKUY1SCYcdvjhmA,7053
-gmicloud/_internal/_client/_decorator.py,sha256=sy4gxzsUB6ORXHw5pqmMf7TTlK41Nmu1fhIhK2AIsbY,670
-gmicloud/_internal/_client/_file_upload_client.py,sha256=1JRs4X57S3EScPIP9w2DC1Uo6_Wbcjumcw3nVM7uIGM,4667
-gmicloud/_internal/_client/_http_client.py,sha256=V1fZ5O-Ja2n1Z0YHa-PkAMHY-yNFw--Dk_httldNYxA,6520
-gmicloud/_internal/_client/_iam_client.py,sha256=57KHyGg_0Vj5AzwhIto0kmbqQYxnixKIOilNO8hCwr0,2698
-gmicloud/_internal/_client/_task_client.py,sha256=76PpI2-ZjHHtGLMxJ_wEOh0mHnmPzVG7sCkWLxV2rAw,5110
-gmicloud/_internal/_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gmicloud/_internal/_manager/_artifact_manager.py,sha256=eUxi7ABAivGK_6B8xo9RXr_pieHyFZLFyDDtOU37SnA,12439
-gmicloud/_internal/_manager/_task_manager.py,sha256=0GYjXRPtJswxDLPmVhLl3LNbQiXZP_49WUvd5OE3wn0,8119
-gmicloud/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gmicloud/tests/test_artifacts.py,sha256=c1MlkaLTaIeVJ3acn92fl3txcDFdy3itOTRhUXaze0E,17120
-gmicloud/tests/test_tasks.py,sha256=AY90zTJdsXk1cxn6Jxhi4TDdwXRiGxz_r_aRk_Jkl8Y,10956
-gmicloud-0.1.0.dist-info/METADATA,sha256=Vu5h1LtOonBVJ98U-noSJEHfnsFS0_N-wvc9gv9ZGzk,4308
-gmicloud-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-gmicloud-0.1.0.dist-info/top_level.txt,sha256=2GhHEguTB3WOeNihOOrIwGp1n7pw_VTJbG8pa5WyyFk,18
-gmicloud-0.1.0.dist-info/RECORD,,