gmicloud 0.1.0__py3-none-any.whl

gmicloud/_internal/_manager/_task_manager.py

@@ -0,0 +1,221 @@
+import os
+
+from .._client._iam_client import IAMClient
+from .._client._task_client import TaskClient
+from .._models import *
+
+
+class TaskManager:
+    """
+    TaskManager handles operations related to tasks, including creation, scheduling, and stopping tasks.
+    """
+
+    def __init__(self, iam_client: IAMClient):
+        """
+        Initialize the TaskManager instance and the associated TaskClient.
+
+        :param iam_client: The IAMClient instance used for authentication
+        """
+        self.iam_client = iam_client
+        self.task_client = TaskClient(iam_client)
+
+    def get_task(self, task_id: str) -> Task:
+        """
+        Retrieve a task by its ID.
+
+        :param task_id: The ID of the task to retrieve.
+        :return: A `Task` object containing the details of the task.
+        :raises ValueError: If `task_id` is invalid (None or empty string).
+        """
+        self._validate_not_empty(task_id, "Task ID")
+
+        return self.task_client.get_task(task_id)
+
+    def get_all_tasks(self) -> List[Task]:
+        """
+        Retrieve a list of all tasks available in the system.
+
+        :return: A list of `Task` objects.
+        """
+        return self.task_client.get_all_tasks(self.iam_client.get_user_id()).tasks
+
+    def create_task(self, task: Task) -> Task:
+        """
+        Create a new task.
+
+        :param task: A `Task` object containing the details of the task to be created.
+        :return: A `Task` object containing the details of the created task.
+        :rtype: Task
+        :raises ValueError: If `task` is None.
+        """
+        self._validate_task(task)
+        if not task.owner:
+            task.owner = TaskOwner(user_id=self.iam_client.get_user_id())
+
+        return self.task_client.create_task(task).task
+
+    def create_task_from_file(self, artifact_id: str, config_file_path: str, trigger_timestamp: int = None) -> Task:
+        """
+        Create a new task using the configuration data from a file.
+
+        :param artifact_id: The ID of the artifact to be used in the task.
+        :param config_file_path: The path to the file containing the task configuration data.
+        :param trigger_timestamp: Optional, for one-off scheduling.
+        :return: A `Task` object containing the details of the created task.
+        :rtype: Task
+        :raises ValueError: If the `file_path` is invalid or the file cannot be read.
+        """
+        self._validate_not_empty(artifact_id, "Artifact ID")
+        self._validate_file_path(config_file_path)
+
+        task = self._read_file_and_parse_task(config_file_path)
+        task.config.ray_task_config.artifact_id = artifact_id
+
+        if trigger_timestamp:
+            task.config.task_scheduling.scheduling_oneoff.trigger_timestamp = trigger_timestamp
+
+        return self.create_task(task)
+
+    def update_task_schedule(self, task: Task):
+        """
+        Update the schedule of an existing task.
+
+        :param task: A `Task` object containing the updated schedule details.
+        :return: None
+        :raises ValueError: If `task` is None.
+        """
+        self._validate_task(task)
+        self._validate_not_empty(task.task_id, "Task ID")
+
+        self.task_client.update_task_schedule(task)
+
+    def update_task_schedule_from_file(self, artifact_id: str, task_id: str, config_file_path: str,
+                                       trigger_timestamp: int = None):
+        """
+        Update the schedule of an existing task using data from a file. The file should contain a valid task definition.
+
+        :param artifact_id: The ID of the artifact to be used in the task.
+        :param task_id: The ID of the task to update.
+        :param config_file_path: The path to the file containing the task configuration data.
+        :param trigger_timestamp: Optional, for one-off scheduling.
+        :return: None
+        :raises ValueError: If the `file_path` is invalid or the file cannot be read.
+        """
+        self._validate_not_empty(artifact_id, "Artifact ID")
+        self._validate_not_empty(task_id, "Task ID")
+        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
+
+        if trigger_timestamp:
+            task.config.task_scheduling.scheduling_oneoff.trigger_timestamp = trigger_timestamp
+
+        self.update_task_schedule(task)
+
+    def start_task(self, task_id: str):
+        """
+        Start a task by its ID.
+
+        :param task_id: The ID of the task to be started.
+        :return: None
+        :raises ValueError: If `task_id` is invalid (None or empty string).
+        """
+        self._validate_not_empty(task_id, "Task ID")
+
+        self.task_client.start_task(task_id)
+
+    def stop_task(self, task_id: str):
+        """
+        Stop a task by its ID.
+
+        :param task_id: The ID of the task to be stopped.
+        :return: None
+        :raises ValueError: If `task_id` is invalid (None or empty string).
+        """
+        self._validate_not_empty(task_id, "Task ID")
+
+        self.task_client.stop_task(task_id)
+
+    def get_usage_data(self, start_timestamp: str, end_timestamp: str) -> GetUsageDataResponse:
+        """
+        Retrieve the usage data of a task within a given time range.
+
+        :param start_timestamp: The start timestamp of the usage data.
+        :param end_timestamp: The end timestamp of the usage data.
+        :return: A `GetUsageDataResponse` object containing the usage data.
+        """
+        self._validate_not_empty(start_timestamp, "Start timestamp")
+        self._validate_not_empty(end_timestamp, "End timestamp")
+
+        return self.task_client.get_usage_data(start_timestamp, end_timestamp)
+
+    def archive_task(self, task_id: str):
+        """
+        Archive a task by its ID.
+
+        :param task_id: The ID of the task to be archived.
+        :return: None
+        :raises ValueError: If `task_id` is invalid (None or empty string).
+        """
+        self._validate_not_empty(task_id, "Task ID")
+
+        self.task_client.archive_task(task_id)
+
+    @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.")
+
+    @staticmethod
+    def _validate_task(task: Task) -> None:
+        """
+        Validate a Task object.
+
+        :param task: The Task object to validate.
+        :raises ValueError: If `task` is None.
+        """
+        if task is None:
+            raise ValueError("Task object is required and cannot be None.")
+
+    @staticmethod
+    def _validate_file_path(file_path: str) -> None:
+        """
+        Validate the file path.
+
+        :param file_path: The file path to validate.
+        :raises ValueError: If `file_path` is None, empty, or does not exist.
+        """
+        if not file_path or not file_path.strip():
+            raise ValueError("File path is required and cannot be empty.")
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+    def _read_file_and_parse_task(self, file_path: str) -> Task:
+        """
+        Read a file and parse it into a Task object.
+
+        :param file_path: The path to the file to be read.
+        :return: A `Task` object parsed from the file content.
+        :raises ValueError: If the file is invalid or cannot be parsed.
+        """
+        self._validate_file_path(file_path)
+
+        with open(file_path, "rb") as file:
+            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)}")
+
+        return task

gmicloud/_internal/_models.py

@@ -0,0 +1,336 @@
+from typing import Optional, List
+from datetime import datetime
+
+from pydantic import BaseModel
+from gmicloud._internal._enums import BuildStatus, TaskEndpointStatus
+
+
+class BigFileMetadata(BaseModel):
+    """
+    Metadata about a large file stored in a GCS bucket.
+    """
+    gcs_link: Optional[str] = ""  # Link to the file stored in Google Cloud Storage.
+    file_name: Optional[str] = ""  # Name of the uploaded file.
+    bucket_name: Optional[str] = ""  # Name of the bucket where the file is stored.
+    upload_time: Optional[datetime]  # Time when the file was uploaded.
+
+
+class ArtifactMetadata(BaseModel):
+    """
+    Metadata information for an artifact.
+    """
+    user_id: Optional[str] = ""  # The user ID associated with this artifact.
+    artifact_name: Optional[str] = ""  # Name of the artifact.
+    artifact_description: Optional[str] = ""  # Description of the artifact.
+    artifact_tags: Optional[List[str]] = ""  # Comma-separated tags for categorizing the artifact.
+    artifact_volume_path: Optional[str] = ""  # Path to the volume where the artifact is stored.
+
+
+class ArtifactData(BaseModel):
+    """
+    Data related to the artifact's creation, upload, and status.
+    """
+    artifact_type: Optional[str] = ""  # The type of the artifact (e.g., model, DockerImage, etc.).
+    artifact_link: Optional[str] = ""  # Link to access the artifact.
+    artifact_resource: Optional[str] = ""  # Resource associated with the artifact (e.g., GCS link, S3 link).
+    build_status: BuildStatus  # Status of the artifact build (e.g., in progress, succeeded, failed).
+    build_error: Optional[str] = ""  # Error message if the build failed.
+    build_file_name: Optional[str] = ""  # Name of the file used for the build.
+    status: Optional[str] = ""  # Status of the artifact (e.g., active, inactive).
+    build_id: Optional[str] = ""  # ID of the build process associated with the artifact.
+    create_at: Optional[datetime]  # Timestamp when the artifact was created.
+    update_at: Optional[datetime]  # Timestamp when the artifact was last updated.
+
+
+class Artifact(BaseModel):
+    """
+    Representation of an artifact, including its data and metadata.
+    """
+    artifact_id: str  # Unique identifier for the artifact.
+    artifact_link: Optional[str] = ""  # Link to access the artifact.
+    build_file_name: Optional[str] = ""  # Name of the file used for the build.
+    build_status: Optional[BuildStatus] = None  # Status of the artifact build (e.g., in progress, succeeded, failed).
+    artifact_data: Optional[ArtifactData] = None  # Data associated with the artifact.
+    artifact_metadata: Optional[ArtifactMetadata] = None  # Metadata describing the artifact.
+    big_files_metadata: Optional[List[BigFileMetadata]] = None  # Metadata for large files associated with the artifact.
+
+
+class GetAllArtifactsResponse(BaseModel):
+    """
+    Response containing a list of all artifacts for a user.
+    """
+    artifacts: list[Artifact]  # List of Artifact objects.
+
+
+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.
+
+
+class CreateArtifactResponse(BaseModel):
+    """
+    Response object after creating an artifact.
+    """
+    artifact_id: str  # ID of the newly created artifact.
+    upload_link: str  # URL to upload the artifact data.
+
+
+class GetBigFileUploadUrlRequest(BaseModel):
+    """
+    Request to generate a pre-signed URL for uploading large files.
+    """
+    artifact_id: Optional[str] = ""  # ID of the artifact for which the upload URL is requested.
+    file_name: Optional[str] = ""  # Name of the file to upload.
+    file_type: Optional[str] = ""  # MIME type of the file.
+
+
+class GetBigFileUploadUrlResponse(BaseModel):
+    """
+    Response containing a pre-signed upload URL for large files.
+    """
+    artifact_id: str  # ID of the artifact.
+    upload_link: str  # Pre-signed upload URL for the file.
+
+
+class RebuildArtifactResponse(BaseModel):
+    """
+    Response object after rebuilding an artifact.
+    """
+    artifact_id: str  # ID of the rebuilt artifact.
+    build_status: BuildStatus  # Status of the artifact build (e.g., in progress, succeeded, failed).
+
+
+class DeleteArtifactResponse(BaseModel):
+    """
+    Response object after deleting an artifact.
+    """
+    artifact_id: str  # ID of the deleted artifact.
+    delete_at: Optional[datetime] = None  # Timestamp when the artifact was deleted.
+    status: Optional[str] = ""  # Status of the deletion process.
+
+
+class DeleteBigfileRequest(BaseModel):
+    """
+    Request to delete a large file associated with an artifact.
+    """
+    artifact_id: str  # ID of the artifact for which the large file is to be deleted.
+    file_name: str  # Name of the large file to delete.
+
+
+class DeleteBigfileResponse(BaseModel):
+    """
+    Response object after deleting a large file.
+    """
+    artifact_id: str  # ID of the artifact.
+    file_name: str  # Name of the deleted file.
+    status: Optional[str] = ""  # Status of the deletion process.
+
+
+class GetArtifactTemplatesResponse(BaseModel):
+    """
+    Response containing a list of artifact templates.
+    """
+    artifact_templates: list["ArtifactTemplate"]  # List of artifact templates.
+
+
+class ArtifactTemplate(BaseModel):
+    """
+    Template for creating an artifact.
+    """
+    artifact_template_id: str  # Unique identifier for the artifact template.
+    artifact_description: Optional[str] = ""  # Description of the artifact template.
+    artifact_name: Optional[str] = ""  # Name of the artifact template.
+    artifact_tags: Optional[List[str]] = None  # Tags associated with the artifact template.
+
+
+class CreateArtifactFromTemplateRequest(BaseModel):
+    """
+    Request object to create a new artifact from a template.
+    """
+    user_id: str  # The user ID creating the artifact.
+    artifact_template_id: str  # The ID of the artifact template to use.
+
+
+class CreateArtifactFromTemplateResponse(BaseModel):
+    """
+    Response object after creating an artifact from a template
+    """
+    artifact_id: str  # ID of the newly created artifact.
+    status: str  # Status of the creation process.
+
+
+class TaskOwner(BaseModel):
+    """
+    Ownership information of a task.
+    """
+    user_id: Optional[str] = ""  # ID of the user owning the task.
+    group_id: Optional[str] = ""  # ID of the group the user belongs to.
+    service_account_id: Optional[str] = ""  # ID of the service account used to execute the task.
+
+
+class ReplicaResource(BaseModel):
+    """
+    Resources allocated for task replicas.
+    """
+    cpu: Optional[int] = 0  # Number of CPU cores allocated.
+    ram_gb: Optional[int] = 0  # Amount of RAM (in GB) allocated.
+    gpu: Optional[int] = 0  # Number of GPUs allocated.
+    gpu_name: Optional[str] = ""  # Type or model of the GPU allocated.
+
+
+class VolumeMount(BaseModel):
+    """
+    Configuration for mounting volumes in a container.
+    """
+    access_mode: Optional[str] = ""  # Access mode for the volume (e.g., read-only, read-write).
+    capacity_GB: Optional[int] = ""  # Capacity of the volume in GB.
+    host_path: Optional[str] = ""  # Path on the host machine where the volume is mounted.
+    mount_path: Optional[str] = ""  # Path where the volume is mounted in the container.
+
+
+class RayTaskConfig(BaseModel):
+    """
+    Configuration settings for Ray tasks.
+    """
+    artifact_id: Optional[str] = ""  # Associated artifact ID.
+    ray_version: Optional[str] = ""  # Version of Ray used.
+    ray_cluster_image: Optional[str] = ""  # Docker image for the Ray cluster.
+    file_path: Optional[str] = ""  # Path to the task file in storage.
+    deployment_name: Optional[str] = ""  # Name of the deployment.
+    replica_resource: Optional[ReplicaResource] = None  # Resources allocated for task replicas.
+    volume_mounts: Optional[VolumeMount] = None  # Configuration for mounted volumes.
+
+
+class OneOffScheduling(BaseModel):
+    """
+    Scheduling configuration for a one-time trigger.
+    """
+    trigger_timestamp: Optional[int] = 0  # Timestamp when the task should start.
+    min_replicas: Optional[int] = 0  # Minimum number of replicas to deploy.
+    max_replicas: Optional[int] = 0  # Maximum number of replicas to deploy.
+
+
+class DailyTrigger(BaseModel):
+    """
+    Scheduling configuration for daily task triggers.
+    """
+    timezone: Optional[str] = ""  # Timezone for the trigger (e.g., "UTC").
+    Hour: Optional[int] = 0  # Hour of the day the task should start (0-23).
+    minute: Optional[int] = 0  # Minute of the hour the task should start (0-59).
+    second: Optional[int] = 0  # Second of the minute the task should start (0-59).
+    min_replicas: Optional[int] = 0  # Minimum number of replicas for this daily trigger.
+    max_replicas: Optional[int] = 0  # Maximum number of replicas for this daily trigger.
+
+
+class DailyScheduling(BaseModel):
+    """
+    Configuration for daily scheduling triggers.
+    """
+    triggers: Optional[list[DailyTrigger]] = None  # List of daily triggers.
+
+
+class TaskScheduling(BaseModel):
+    """
+    Complete scheduling configuration for a task.
+    """
+    scheduling_oneoff: Optional[OneOffScheduling] = None  # One-time scheduling configuration.
+    scheduling_daily: Optional[DailyScheduling] = None  # Daily scheduling configuration.
+
+
+class TaskConfig(BaseModel):
+    """
+    Configuration data for a task.
+    """
+    ray_task_config: Optional[RayTaskConfig] = None  # Configuration for a Ray-based task.
+    task_scheduling: Optional[TaskScheduling] = None  # Scheduling configuration for the task.
+    create_timestamp: Optional[int] = 0  # Timestamp when the task was created.
+    last_update_timestamp: Optional[int] = 0  # Timestamp when the task was last updated.
+
+
+class TaskInfo(BaseModel):
+    """
+    Additional information about a task.
+    """
+    endpoint_status: Optional[TaskEndpointStatus] = None  # Current status of the task (e.g., running, stopped).
+    endpoint: Optional[str] = ""  # API endpoint exposed by the task, if applicable.
+
+
+class UserPreference(BaseModel):
+    """
+    User preference for a task.
+    """
+    block_list: Optional[List[str]] = None  # List of tasks to exclude.
+    preference_scale: Optional[int] = 0  # Scale of user preference.
+
+
+class Task(BaseModel):
+    """
+    Representation of a task.
+    """
+    task_id: Optional[str] = None  # Unique identifier for the task.
+    owner: Optional[TaskOwner] = None  # Ownership information of the task.
+    config: Optional[TaskConfig] = None  # Configuration data for the task.
+    info: Optional[TaskInfo] = None  # Additional information about the task.
+    task_status: Optional[str] = ""  # Status of the task.
+    readiness_status: Optional[str] = ""  # Readiness status of the task.
+    user_preference: Optional[UserPreference] = None  # User preference for the task.
+
+
+class GetAllTasksResponse(BaseModel):
+    """
+    Response containing a list of all tasks.
+    """
+    tasks: Optional[list[Task]] = None  # List of tasks.
+
+
+class CreateTaskResponse(BaseModel):
+    task: Task  # The created task.
+    upload_link: str  # URL to upload the task data.
+
+
+class LoginResponse(BaseModel):
+    """
+    Response object for user login.
+    """
+    accessToken: str  # Access token for the user session.
+    refreshToken: str  # Refresh token for the user session.
+
+
+class GPUUsage(BaseModel):
+    """
+    GPU usage data for a task.
+    """
+    geo_location: Optional[str] = ""  # Location of the GPU.
+    gpu_count: Optional[int] = ""  # Number of GPUs.
+    gpu_type: Optional[str] = ""  # Type of GPU.
+
+
+class Usage(BaseModel):
+    """
+    Usage data for a task.
+    """
+    user_id: Optional[str] = ""  # ID of the user.
+    task_id: Optional[str] = ""  # ID of the task.
+    gpu_usage_list: Optional[List[GPUUsage]] = None  # List of GPU usage data.
+    replica_count: Optional[int] = 0  # Number of replicas.
+    timestamp: Optional[int] = 0  # Timestamp of the usage data.
+
+
+class GetUsageDataResponse(BaseModel):
+    """
+    Response containing the usage data of a task.
+    """
+    usage_data: list[Usage] = None  # List of usage data for the task.
+
+
+class LoginRequest(BaseModel):
+    """
+    Request object for user login.
+    """
+    email: str  # User email.
+    password: str  # User password.

gmicloud/client.py

@@ -0,0 +1,51 @@
+import os
+
+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
+
+
+class Client:
+    def __init__(self, client_id: Optional[str] = "", email: Optional[str] = "", password: Optional[str] = ""):
+        if not client_id or not client_id.strip():
+            client_id = os.getenv("GMI_CLOUD_CLIENT_ID")
+        if not email or not email.strip():
+            email = os.getenv("GMI_CLOUD_EMAIL")
+        if not password or not password.strip():
+            password = os.getenv("GMI_CLOUD_PASSWORD")
+
+        if not client_id:
+            raise ValueError("Client ID must be provided.")
+        if not email:
+            raise ValueError("Email must be provided.")
+        if not password:
+            raise ValueError("Password must be provided.")
+
+        self.iam_client = IAMClient(client_id, email, password)
+        self.iam_client.login()
+
+        # Managers are lazily initialized through private attributes
+        self._artifact_manager = None
+        self._task_manager = None
+
+    @property
+    def artifact_manager(self):
+        """
+        Lazy initialization for ArtifactManager.
+        Ensures the Client instance controls its lifecycle.
+        """
+        if self._artifact_manager is None:
+            self._artifact_manager = ArtifactManager(self.iam_client)
+        return self._artifact_manager
+
+    @property
+    def task_manager(self):
+        """
+        Lazy initialization for TaskManager.
+        Ensures the Client instance controls its lifecycle.
+        """
+        if self._task_manager is None:
+            self._task_manager = TaskManager(self.iam_client)
+        return self._task_manager