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

gmicloud/client.py

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

gmicloud/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.7.dist-info/METADATA

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

gmicloud-0.1.7.dist-info/RECORD

@@ -0,0 +1,28 @@
+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=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=2l65aZdQxyXlY0Dj23P6NFf59_zopgf9OoUMLAz5T2U,22685
+gmicloud/_internal/_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=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=yK4veVwCY1cipy3rdnGvhnKNvkBx3SYYpHKqzjtXJn0,20731
+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/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.5.dist-info → gmicloud-0.1.7.dist-info}/WHEEL

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