hypercli-sdk 0.4.7__tar.gz → 0.5.0__tar.gz

{hypercli_sdk-0.4.7 → hypercli_sdk-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-sdk
-Version: 0.4.7
+Version: 0.5.0
 Summary: Python SDK for HyperCLI - GPU orchestration and LLM API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com

{hypercli_sdk-0.4.7 → hypercli_sdk-0.5.0}/hypercli/__init__.py

@@ -6,10 +6,10 @@ from .instances import GPUType, GPUConfig, Region, GPUPricing, PricingTier
 from .jobs import Job, JobMetrics, GPUMetrics, find_job, find_by_id, find_by_hostname, find_by_ip
 from .renders import Render, RenderStatus
 from .files import File, AsyncFiles
-from .job import BaseJob, ComfyUIJob, apply_params, apply_graph_modes, find_node, find_nodes, load_template, graph_to_api, expand_subgraphs, DEFAULT_OBJECT_INFO
+from .job import BaseJob, ComfyUIJob, GradioJob, apply_params, apply_graph_modes, find_node, find_nodes, load_template, graph_to_api, expand_subgraphs, DEFAULT_OBJECT_INFO
 from .logs import LogStream, stream_logs, fetch_logs
 
-__version__ = "0.4.7"
+__version__ = "0.5.0"
 __all__ = [
     "HyperCLI",
     "configure",
@@ -42,6 +42,7 @@ __all__ = [
     # Job helpers
     "BaseJob",
     "ComfyUIJob",
+    "GradioJob",
     # Workflow utils
     "apply_params",
     "apply_graph_modes",

{hypercli_sdk-0.4.7 → hypercli_sdk-0.5.0}/hypercli/job/__init__.py

@@ -11,10 +11,12 @@ from .comfyui import (
     expand_subgraphs,
     DEFAULT_OBJECT_INFO,
 )
+from .gradio import GradioJob
 
 __all__ = [
     "BaseJob",
     "ComfyUIJob",
+    "GradioJob",
     "apply_params",
     "apply_graph_modes",
     "find_node",

hypercli_sdk-0.5.0/hypercli/job/gradio.py

@@ -0,0 +1,118 @@
+"""Gradio job helpers for GPU workloads running Gradio-based services"""
+from typing import TYPE_CHECKING
+
+from .base import BaseJob
+
+
+if TYPE_CHECKING:
+    from ..client import HyperCLI
+
+
+class GradioJob(BaseJob):
+    """Gradio-specific job with service connection helpers.
+
+    Used for GPU workloads that expose a Gradio API (e.g., WhisperX transcription).
+    Supports HTTPS load balancer with bearer token auth (same pattern as ComfyUI).
+    """
+
+    DEFAULT_GPU_TYPE = "l4"
+    HEALTH_ENDPOINT = "/"
+    HEALTH_TIMEOUT = 10.0
+    GRADIO_PORT = 7860
+
+    def __init__(self, client: "HyperCLI", job, use_lb: bool = False, use_auth: bool = False):
+        super().__init__(client, job)
+        self._use_lb = use_lb
+        self.use_auth = use_auth
+        self._job_token: str | None = None
+
+    @property
+    def use_lb(self) -> bool:
+        return self._use_lb
+
+    @use_lb.setter
+    def use_lb(self, value: bool):
+        self._use_lb = value
+        self._base_url = None
+
+    @property
+    def base_url(self) -> str:
+        """Gradio base URL - HTTPS if using lb, HTTP otherwise"""
+        if not self._base_url and self.hostname:
+            if self._use_lb:
+                self._base_url = f"https://{self.hostname}"
+            else:
+                self._base_url = f"http://{self.hostname}:{self.GRADIO_PORT}"
+        return self._base_url or ""
+
+    @property
+    def auth_headers(self) -> dict:
+        """Headers for authenticated requests"""
+        if self.use_auth:
+            if not self._job_token:
+                self._job_token = self.client.jobs.token(self.job_id)
+            return {"Authorization": f"Bearer {self._job_token}"}
+        return super().auth_headers
+
+    @property
+    def job_token(self) -> str:
+        """Get the job-specific bearer token for Gradio API auth"""
+        if not self._job_token:
+            self._job_token = self.client.jobs.token(self.job_id)
+        return self._job_token
+
+    @classmethod
+    def create_for_service(
+        cls,
+        client: "HyperCLI",
+        image: str,
+        gpu_type: str = None,
+        gpu_count: int = 1,
+        runtime: int = 3600,
+        lb: int = None,
+        auth: bool = True,
+        **kwargs,
+    ) -> "GradioJob":
+        """Create a new Gradio job for a specific Docker image.
+
+        Args:
+            client: HyperCLI client instance
+            image: Docker image to run (e.g., "ghcr.io/comput3ai/c3-whisperx-gradio:latest")
+            gpu_type: GPU type (default: l4)
+            gpu_count: Number of GPUs
+            runtime: Max runtime in seconds
+            lb: Port for HTTPS load balancer (default: 7860). If set, uses HTTPS.
+            auth: Enable Bearer token auth on load balancer (default: True)
+        """
+        if lb is None:
+            lb = cls.GRADIO_PORT
+
+        ports = kwargs.pop("ports", {}) or {}
+        if lb:
+            ports["lb"] = lb
+        else:
+            ports[str(cls.GRADIO_PORT)] = cls.GRADIO_PORT
+
+        job = client.jobs.create(
+            image=image,
+            gpu_type=gpu_type or cls.DEFAULT_GPU_TYPE,
+            gpu_count=gpu_count,
+            runtime=runtime,
+            ports=ports,
+            auth=auth,
+            **kwargs,
+        )
+        return cls(client, job, use_lb=bool(lb), use_auth=auth)
+
+    def connect(self):
+        """Return a gradio_client.Client connected to this instance.
+
+        Requires: pip install gradio-client
+
+        Returns:
+            gradio_client.Client configured with auth headers
+        """
+        from gradio_client import Client
+
+        headers = self.auth_headers if self.use_auth else {}
+        return Client(self.base_url, headers=headers)

{hypercli_sdk-0.4.7 → hypercli_sdk-0.5.0}/hypercli/renders.py

@@ -337,3 +337,79 @@ class Renders:
             )
         """
         return self._flow("/api/flow/first-last-frame-video", prompt=prompt, start_image_url=start_image_url, end_image_url=end_image_url, negative=negative, width=width, height=height, notify_url=notify_url)
+
+    def audio_to_text(
+        self,
+        audio_url: str,
+        notify_url: str = None,
+    ) -> Render:
+        """Transcribe audio/video to text using WhisperX.
+
+        Args:
+            audio_url: URL of the audio or video file to transcribe
+            notify_url: Optional webhook URL for completion notification
+
+        Returns:
+            Render object. When completed, result_url points to a JSON file
+            containing {"text": "transcription..."}.
+
+        Example:
+            render = client.renders.audio_to_text("https://example.com/recording.mp3")
+        """
+        return self._flow("/api/flow/audio-to-text", audio_url=audio_url, notify_url=notify_url)
+
+    def text_to_speech(
+        self,
+        text: str,
+        mode: str = "custom",
+        language: str = "Auto",
+        speaker: str = None,
+        style: str = None,
+        model_size: str = None,
+        voice_description: str = None,
+        ref_audio_url: str = None,
+        ref_text: str = None,
+        use_xvector_only: bool = None,
+        notify_url: str = None,
+    ) -> Render:
+        """Generate speech from text using Qwen3-TTS.
+
+        Three modes:
+        - "custom": Predefined speakers with optional style instructions
+        - "design": Describe any voice in natural language
+        - "clone": Clone a voice from reference audio
+
+        Args:
+            text: Text to synthesize
+            mode: TTS mode ("custom", "design", or "clone")
+            language: Language (Auto, English, Chinese, Japanese, Korean, etc.)
+            speaker: Speaker name for custom mode (Ryan, Serena, etc.)
+            style: Style instruction for custom mode (e.g. "Speak cheerfully")
+            model_size: Model size ("0.6B" or "1.7B")
+            voice_description: Voice description for design mode
+            ref_audio_url: Reference audio URL for clone mode
+            ref_text: Transcript of reference audio for clone mode
+            use_xvector_only: Use x-vector only for clone mode
+            notify_url: Optional webhook URL for completion notification
+
+        Returns:
+            Render object. When completed, result_url points to the WAV audio file.
+
+        Example:
+            render = client.renders.text_to_speech("Hello!", mode="design",
+                voice_description="A young Indian male, enthusiastic")
+        """
+        return self._flow(
+            "/api/flow/text-to-speech",
+            text=text,
+            mode=mode,
+            language=language,
+            speaker=speaker,
+            style=style,
+            model_size=model_size,
+            voice_description=voice_description,
+            ref_audio_url=ref_audio_url,
+            ref_text=ref_text,
+            use_xvector_only=use_xvector_only,
+            notify_url=notify_url,
+        )

{hypercli_sdk-0.4.7 → hypercli_sdk-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-sdk"
-version = "0.4.7"
+version = "0.5.0"
 description = "Python SDK for HyperCLI - GPU orchestration and LLM API"
 readme = "README.md"
 requires-python = ">=3.10"