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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-sdk
-Version: 0.4.6
+Version: 0.4.7
 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.6 → hypercli_sdk-0.4.7}/hypercli/__init__.py

@@ -1,20 +1,17 @@
 """HyperCLI SDK - Python client for HyperCLI API"""
 from .client import HyperCLI
-
-# Backwards compatibility alias
-C3 = HyperCLI
 from .config import configure, GHCR_IMAGES, COMFYUI_IMAGE
 from .http import APIError, AsyncHTTPClient
 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, DEFAULT_OBJECT_INFO
+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 .logs import LogStream, stream_logs, fetch_logs
 
-__version__ = "0.2.1"
+__version__ = "0.4.7"
 __all__ = [
-    "HyperCLI", "C3",
+    "HyperCLI",
     "configure",
     "APIError",
     # Images
@@ -52,6 +49,7 @@ __all__ = [
     "find_nodes",
     "load_template",
     "graph_to_api",
+    "expand_subgraphs",
     "DEFAULT_OBJECT_INFO",
     # Log streaming
     "LogStream",

{hypercli_sdk-0.4.6 → hypercli_sdk-0.4.7}/hypercli/client.py

@@ -14,18 +14,18 @@ class HyperCLI:
     HyperCLI API Client
 
     Usage:
-        from hypercli import C3
+        from hypercli import HyperCLI
 
-        c3 = C3()  # Uses HYPERCLI_API_KEY from env or ~/.hypercli/config
+        client = HyperCLI()  # Uses HYPERCLI_API_KEY from env or ~/.hypercli/config
         # or
-        c3 = C3(api_key="your_key")
+        client = HyperCLI(api_key="your_key")
 
         # Billing
-        balance = c3.billing.balance()
+        balance = client.billing.balance()
         print(f"Balance: ${balance.total}")
 
         # Jobs
-        job = c3.jobs.create(
+        job = client.jobs.create(
             image="nvidia/cuda:12.0",
             gpu_type="l40s",
             command="python train.py"
@@ -33,7 +33,7 @@ class HyperCLI:
         print(f"Job: {job.job_id}")
 
         # User
-        user = c3.user.get()
+        user = client.user.get()
     """
 
     def __init__(self, api_key: str = None, api_url: str = None):

{hypercli_sdk-0.4.6 → hypercli_sdk-0.4.7}/hypercli/config.py

@@ -11,7 +11,7 @@ DEFAULT_WS_URL = "wss://api.hypercli.com"
 WS_LOGS_PATH = "/orchestra/ws/logs"  # WebSocket path for job logs: {WS_URL}{WS_LOGS_PATH}/{job_key}
 
 # GHCR images
-GHCR_IMAGES = "ghcr.io/hypercliai/images"
+GHCR_IMAGES = "ghcr.io/compute3ai/images"
 COMFYUI_IMAGE = f"{GHCR_IMAGES}/comfyui"
 
 

{hypercli_sdk-0.4.6 → hypercli_sdk-0.4.7}/hypercli/files.py

@@ -23,7 +23,7 @@ class File:
     filename: str
     content_type: str
     file_size: int
-    url: str  # Internal S3 reference - only valid for use in C3 renders
+    url: str  # Internal S3 reference - only valid for use in HyperCLI renders
     state: str | None = None  # processing, done, failed (for async uploads)
     error: str | None = None  # Error message if state=failed
     created_at: str | None = None
@@ -72,11 +72,11 @@ class Files:
 
         Returns:
             File object with id and internal url for use in render calls.
-            The url is an S3 reference that only works within C3.
+            The url is an S3 reference that only works within HyperCLI.
 
         Example:
-            file = c3.files.upload("./my_image.png")
-            render = c3.renders.image_to_video("dancing", file.url)
+            file = client.files.upload("./my_image.png")
+            render = client.renders.image_to_video("dancing", file.url)
         """
         # Read file
         with open(file_path, "rb") as f:
@@ -106,7 +106,7 @@ class Files:
             File object with id and url for use in render calls
 
         Example:
-            file = c3.files.upload_bytes(image_bytes, "image.png", "image/png")
+            file = client.files.upload_bytes(image_bytes, "image.png", "image/png")
         """
         files = {"file": (filename, content, content_type)}
         data = self._http.post_multipart("/api/files/multi", files=files)
@@ -126,8 +126,8 @@ class Files:
             File object with id and state=processing.
 
         Example:
-            file = c3.files.upload_url("https://example.com/image.png")
-            file = c3.files.wait_ready(file.id)  # Wait for completion
+            file = client.files.upload_url("https://example.com/image.png")
+            file = client.files.wait_ready(file.id)  # Wait for completion
         """
         payload = {"url": url}
         if path:
@@ -159,8 +159,8 @@ class Files:
         Example:
             import base64
             b64_data = base64.b64encode(image_bytes).decode()
-            file = c3.files.upload_b64(b64_data, "image.png", "image/png")
-            file = c3.files.wait_ready(file.id)
+            file = client.files.upload_b64(b64_data, "image.png", "image/png")
+            file = client.files.wait_ready(file.id)
         """
         payload = {"data": data, "filename": filename}
         if content_type:
@@ -216,8 +216,8 @@ class Files:
             ValueError: If file upload failed
 
         Example:
-            file = c3.files.upload_url("https://example.com/image.png")
-            file = c3.files.wait_ready(file.id, timeout=30)
+            file = client.files.upload_url("https://example.com/image.png")
+            file = client.files.wait_ready(file.id, timeout=30)
             print(f"Ready: {file.url}")
         """
         start = time.time()

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

@@ -8,6 +8,7 @@ from .comfyui import (
     find_nodes,
     load_template,
     graph_to_api,
+    expand_subgraphs,
     DEFAULT_OBJECT_INFO,
 )
 
@@ -20,5 +21,6 @@ __all__ = [
     "find_nodes",
     "load_template",
     "graph_to_api",
+    "expand_subgraphs",
     "DEFAULT_OBJECT_INFO",
 ]

{hypercli_sdk-0.4.6 → hypercli_sdk-0.4.7}/hypercli/job/base.py

@@ -4,7 +4,7 @@ import httpx
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ..client import C3
+    from ..client import HyperCLI
     from ..jobs import Job
 
 
@@ -16,8 +16,8 @@ class BaseJob:
     HEALTH_ENDPOINT: str = "/"
     HEALTH_TIMEOUT: float = 5.0
 
-    def __init__(self, c3: "C3", job: "Job"):
-        self.c3 = c3
+    def __init__(self, client: "HyperCLI", job: "Job"):
+        self.client = client
         self.job = job
         self._base_url: str | None = None
 
@@ -39,24 +39,24 @@ class BaseJob:
     @property
     def auth_headers(self) -> dict:
         """Headers for authenticated requests. Override in subclasses for custom auth."""
-        return {"Authorization": f"Bearer {self.c3._api_key}"}
+        return {"Authorization": f"Bearer {self.client._api_key}"}
 
     @classmethod
-    def get_running(cls, c3: "C3", image_filter: str = None) -> "BaseJob | None":
+    def get_running(cls, client: "HyperCLI", image_filter: str = None) -> "BaseJob | None":
         """Find an existing running job, optionally filtering by image"""
-        jobs = c3.jobs.list(state="running")
+        jobs = client.jobs.list(state="running")
         for job in jobs:
             if image_filter and image_filter not in job.docker_image:
                 continue
-            return cls(c3, job)
+            return cls(client, job)
         return None
 
     @classmethod
-    def get_by_instance(cls, c3: "C3", instance: str, state: str = "running") -> "BaseJob":
+    def get_by_instance(cls, client: "HyperCLI", instance: str, state: str = "running") -> "BaseJob":
         """Get a job by ID, hostname, or IP address.
 
         Args:
-            c3: C3 client
+            client: HyperCLI client instance
             instance: Job ID (UUID), hostname (partial match), or IP address
             state: State filter for hostname/IP search (default: running)
 
@@ -68,15 +68,15 @@ class BaseJob:
         """
         from ..jobs import find_job
 
-        job = find_job(c3.jobs, instance, state=state)
+        job = find_job(client.jobs, instance, state=state)
         if not job:
             raise ValueError(f"No job found matching: {instance}")
-        return cls(c3, job)
+        return cls(client, job)
 
     @classmethod
     def create(
         cls,
-        c3: "C3",
+        client: "HyperCLI",
         image: str = None,
         gpu_type: str = None,
         gpu_count: int = 1,
@@ -84,19 +84,19 @@ class BaseJob:
         **kwargs,
     ) -> "BaseJob":
         """Create a new job"""
-        job = c3.jobs.create(
+        job = client.jobs.create(
             image=image or cls.DEFAULT_IMAGE,
             gpu_type=gpu_type or cls.DEFAULT_GPU_TYPE,
             gpu_count=gpu_count,
             runtime=runtime,
             **kwargs,
         )
-        return cls(c3, job)
+        return cls(client, job)
 
     @classmethod
     def get_or_create(
         cls,
-        c3: "C3",
+        client: "HyperCLI",
         image: str = None,
         gpu_type: str = None,
         gpu_count: int = 1,
@@ -106,12 +106,12 @@ class BaseJob:
     ) -> "BaseJob":
         """Get existing running job or create new one"""
         if reuse:
-            existing = cls.get_running(c3, image_filter=image or cls.DEFAULT_IMAGE)
+            existing = cls.get_running(client, image_filter=image or cls.DEFAULT_IMAGE)
             if existing:
                 return existing
 
         return cls.create(
-            c3,
+            client,
             image=image,
             gpu_type=gpu_type,
             gpu_count=gpu_count,
@@ -121,7 +121,7 @@ class BaseJob:
 
     def refresh(self) -> "BaseJob":
         """Refresh job state from API"""
-        self.job = self.c3.jobs.get(self.job_id)
+        self.job = self.client.jobs.get(self.job_id)
         self._base_url = None
         return self
 
@@ -241,9 +241,9 @@ class BaseJob:
 
     def shutdown(self) -> dict:
         """Cancel the job"""
-        return self.c3.jobs.cancel(self.job_id)
+        return self.client.jobs.cancel(self.job_id)
 
     def extend(self, runtime: int) -> "BaseJob":
         """Extend job runtime"""
-        self.job = self.c3.jobs.extend(self.job_id, runtime=runtime)
+        self.job = self.client.jobs.extend(self.job_id, runtime=runtime)
         return self

{hypercli_sdk-0.4.6 → hypercli_sdk-0.4.7}/hypercli/job/comfyui.py

@@ -12,7 +12,7 @@ from ..config import COMFYUI_IMAGE
 
 
 if TYPE_CHECKING:
-    from ..client import C3
+    from ..client import HyperCLI
 
 
 # Default object_info for offline workflow conversion (no running instance needed)
@@ -495,6 +495,235 @@ def apply_params(workflow: dict, **params) -> dict:
     return workflow
 
 
+def expand_subgraphs(graph: dict, debug: bool = False) -> dict:
+    """
+    Expand subgraph/group nodes into their constituent nodes.
+
+    ComfyUI supports "workflow components" (group nodes) where a subgraph is
+    collapsed into a single node with a UUID type. These must be expanded
+    before the workflow can be executed.
+
+    Args:
+        graph: Workflow in graph format (may contain subgraph definitions)
+        debug: If True, print debug info
+
+    Returns:
+        New graph with subgraphs expanded (original graph not modified)
+    """
+    import copy
+
+    # Check if there are subgraph definitions
+    subgraphs = {sg["id"]: sg for sg in graph.get("definitions", {}).get("subgraphs", [])}
+    if not subgraphs:
+        return graph  # No subgraphs, return as-is
+
+    # Deep copy to avoid mutating original
+    graph = copy.deepcopy(graph)
+
+    # Find group nodes that reference subgraphs
+    nodes = graph.get("nodes", [])
+    links = graph.get("links", [])
+
+    # Track new nodes and links to add
+    new_nodes = []
+    new_links = []
+    nodes_to_remove = set()
+    links_to_remove = set()
+
+    # Track ID remapping for each expanded subgraph
+    # We prefix subgraph node IDs to avoid conflicts
+    next_node_id = graph.get("last_node_id", 0) + 1
+    next_link_id = graph.get("last_link_id", 0) + 1
+
+    for node in nodes:
+        node_type = str(node.get("type", ""))
+        node_id = node.get("id")
+        mode = node.get("mode", 0)
+
+        if node_type not in subgraphs:
+            continue
+
+        # Skip bypassed/muted group nodes
+        if mode in (2, 4):
+            if debug:
+                print(f"Skipping bypassed group node {node_id}")
+            nodes_to_remove.add(node_id)
+            # Remove links to/from this node
+            for link in links:
+                if link[1] == node_id or link[3] == node_id:
+                    links_to_remove.add(link[0])
+            continue
+
+        if debug:
+            print(f"Expanding group node {node_id} -> subgraph {node_type[:20]}...")
+
+        sg = subgraphs[node_type]
+        sg_nodes = sg.get("nodes", [])
+        sg_links = sg.get("links", [])
+
+        # Build ID mapping: old_sg_node_id -> new_node_id
+        id_map = {}
+        for sg_node in sg_nodes:
+            old_id = sg_node.get("id")
+            id_map[old_id] = next_node_id
+            next_node_id += 1
+
+        # Apply widget values from proxyWidgets
+        proxy_widgets = node.get("properties", {}).get("proxyWidgets", [])
+        widget_values = node.get("widgets_values", [])
+
+        # proxyWidgets format: [[target_node_id, widget_name], ...]
+        # widget_values are in same order as proxyWidgets
+        widget_overrides = {}  # {node_id: {widget_name: value}}
+        for i, (target_id, widget_name) in enumerate(proxy_widgets):
+            if i < len(widget_values):
+                target_id = str(target_id)
+                if target_id not in widget_overrides:
+                    widget_overrides[target_id] = {}
+                widget_overrides[target_id][widget_name] = widget_values[i]
+
+        # Copy subgraph nodes with new IDs and apply widget overrides
+        for sg_node in sg_nodes:
+            old_id = sg_node.get("id")
+            new_node = copy.deepcopy(sg_node)
+            new_node["id"] = id_map[old_id]
+
+            # Apply widget overrides
+            if str(old_id) in widget_overrides:
+                overrides = widget_overrides[str(old_id)]
+                sg_widgets = new_node.get("widgets_values", [])
+
+                # Need to find widget index by name - use input order
+                # For simplicity, just update widgets_values if it's a dict
+                if isinstance(sg_widgets, dict):
+                    sg_widgets.update(overrides)
+                else:
+                    # For list format, we need the node's input spec to map names to indices
+                    # For now, handle common cases
+                    node_type_inner = new_node.get("type", "")
+                    if "text" in overrides and node_type_inner in ("CLIPTextEncode", "CLIPTextEncodeFlux"):
+                        # text is usually first widget
+                        if sg_widgets:
+                            sg_widgets[0] = overrides["text"]
+                        else:
+                            new_node["widgets_values"] = [overrides["text"]]
+
+            new_nodes.append(new_node)
+
+        # Build link ID mapping: old_link_id -> new_link_id
+        link_id_map = {}
+
+        # Copy subgraph links with remapped IDs
+        # Subgraph links can be dicts or arrays
+        for sg_link in sg_links:
+            if isinstance(sg_link, dict):
+                old_link_id = sg_link.get("id")
+                from_node = sg_link.get("origin_id")
+                from_slot = sg_link.get("origin_slot", 0)
+                to_node = sg_link.get("target_id")
+                to_slot = sg_link.get("target_slot", 0)
+                link_type = sg_link.get("type", "")
+            else:
+                # Array format: [link_id, from_node, from_slot, to_node, to_slot, type]
+                old_link_id, from_node, from_slot, to_node, to_slot, link_type = sg_link[:6]
+
+            # Remap node IDs
+            new_from = id_map.get(from_node, from_node)
+            new_to = id_map.get(to_node, to_node)
+
+            new_link = [next_link_id, new_from, from_slot, new_to, to_slot, link_type]
+            link_id_map[old_link_id] = next_link_id
+            next_link_id += 1
+            new_links.append(new_link)
+
+        # Update node input link references using the link ID mapping
+        for new_node in new_nodes:
+            for inp in new_node.get("inputs", []):
+                old_link = inp.get("link")
+                if old_link is not None and old_link in link_id_map:
+                    inp["link"] = link_id_map[old_link]
+
+        # Helper to get link fields from dict or array format
+        def get_link_fields(lnk):
+            if isinstance(lnk, dict):
+                return (lnk.get("id"), lnk.get("origin_id"), lnk.get("origin_slot", 0),
+                        lnk.get("target_id"), lnk.get("target_slot", 0), lnk.get("type", ""))
+            return tuple(lnk[:6])
+
+        # Rewire external connections
+        # Group node inputs -> subgraph input nodes
+        sg_inputs = sg.get("inputs", [])
+        for inp in node.get("inputs", []):
+            link_id = inp.get("link")
+            if link_id is None:
+                continue
+
+            # Find which subgraph input this maps to
+            inp_name = inp.get("name")
+            for sg_inp in sg_inputs:
+                if sg_inp.get("name") == inp_name or sg_inp.get("label") == inp.get("label"):
+                    # Find the internal link that connects to this input
+                    for sg_link_id in sg_inp.get("linkIds", []):
+                        # Find the link in sg_links
+                        for sg_link in sg_links:
+                            lf = get_link_fields(sg_link)
+                            if lf[0] == sg_link_id:
+                                # Redirect external link to the internal target
+                                target_node = id_map.get(lf[3], lf[3])
+                                target_slot = lf[4]
+
+                                # Update the external link's target
+                                for link in links:
+                                    if link[0] == link_id:
+                                        link[3] = target_node
+                                        link[4] = target_slot
+                                        break
+                                break
+                    break
+
+        # Group node outputs -> subgraph output nodes
+        sg_outputs = sg.get("outputs", [])
+        for out_idx, out in enumerate(node.get("outputs", [])):
+            out_links = out.get("links", [])
+            if not out_links:
+                continue
+
+            # Find which subgraph output this maps to
+            for sg_out in sg_outputs:
+                # Match by index or name
+                for sg_link_id in sg_out.get("linkIds", []):
+                    # Find the internal link
+                    for sg_link in sg_links:
+                        lf = get_link_fields(sg_link)
+                        if lf[0] == sg_link_id:
+                            # This internal link's source is the real output
+                            source_node = id_map.get(lf[1], lf[1])
+                            source_slot = lf[2]
+
+                            # Redirect all external links from this output
+                            for ext_link_id in out_links:
+                                for link in links:
+                                    if link[0] == ext_link_id:
+                                        link[1] = source_node
+                                        link[2] = source_slot
+                                        break
+                            break
+                    break
+
+        nodes_to_remove.add(node_id)
+
+    # Apply changes
+    graph["nodes"] = [n for n in nodes if n.get("id") not in nodes_to_remove] + new_nodes
+    graph["links"] = [l for l in links if l[0] not in links_to_remove] + new_links
+    graph["last_node_id"] = next_node_id
+    graph["last_link_id"] = next_link_id
+
+    if debug:
+        print(f"Expanded {len(nodes_to_remove)} group nodes, added {len(new_nodes)} nodes")
+
+    return graph
+
+
 def graph_to_api(graph: dict, object_info: dict = None, debug: bool = False) -> dict:
     """
     Convert ComfyUI graph format (from UI) to API format (for /prompt endpoint).
@@ -507,6 +736,9 @@ def graph_to_api(graph: dict, object_info: dict = None, debug: bool = False) ->
     Returns:
         Workflow in API format (node IDs as keys)
     """
+    # First, expand any subgraphs/group nodes
+    graph = expand_subgraphs(graph, debug=debug)
+
     if object_info is None:
         object_info = DEFAULT_OBJECT_INFO
     api = {}
@@ -670,8 +902,8 @@ class ComfyUIJob(BaseJob):
 
     COMFYUI_PORT = 8188
 
-    def __init__(self, c3: "C3", job, template: str = None, use_lb: bool = False, use_auth: bool = False):
-        super().__init__(c3, job)
+    def __init__(self, client: "HyperCLI", job, template: str = None, use_lb: bool = False, use_auth: bool = False):
+        super().__init__(client, job)
         self._object_info: dict | None = None
         self._auth_headers: dict | None = None
         self._job_token: str | None = None
@@ -707,16 +939,16 @@ class ComfyUIJob(BaseJob):
         if self.use_auth:
             # Use job-specific token for LB auth
             if not self._job_token:
-                self._job_token = self.c3.jobs.token(self.job_id)
+                self._job_token = self.client.jobs.token(self.job_id)
             return {"Authorization": f"Bearer {self._job_token}"}
         else:
             # Use API key for direct connections
-            return {"Authorization": f"Bearer {self.c3._api_key}"}
+            return {"Authorization": f"Bearer {self.client._api_key}"}
 
     @classmethod
     def create_for_template(
         cls,
-        c3: "C3",
+        client: "HyperCLI",
         template: str,
         gpu_type: str = None,
         gpu_count: int = 1,
@@ -728,7 +960,7 @@ class ComfyUIJob(BaseJob):
         """Create a new ComfyUI job configured for a specific template.
 
         Args:
-            c3: C3 client
+            client: HyperCLI client instance
             template: Template name (passed as COMFYUI_TEMPLATES env var)
             gpu_type: GPU type
             gpu_count: Number of GPUs
@@ -747,7 +979,7 @@ class ComfyUIJob(BaseJob):
             # Direct port exposure (HTTP)
             ports[str(cls.COMFYUI_PORT)] = cls.COMFYUI_PORT
 
-        job = c3.jobs.create(
+        job = client.jobs.create(
             image=cls.DEFAULT_IMAGE,
             gpu_type=gpu_type or cls.DEFAULT_GPU_TYPE,
             gpu_count=gpu_count,
@@ -757,12 +989,12 @@ class ComfyUIJob(BaseJob):
             auth=auth,
             **kwargs,
         )
-        return cls(c3, job, template=template, use_lb=bool(lb), use_auth=auth)
+        return cls(client, job, template=template, use_lb=bool(lb), use_auth=auth)
 
     @classmethod
     def get_instance(
         cls,
-        c3: "C3",
+        client: "HyperCLI",
         instance: str,
         use_lb: bool = False,
         use_auth: bool = False,
@@ -770,17 +1002,17 @@ class ComfyUIJob(BaseJob):
         """Connect to a specific ComfyUI instance by job ID or hostname.
 
         Args:
-            c3: C3 client
+            client: HyperCLI client instance
             instance: Job ID (UUID) or hostname
             use_lb: Whether instance uses HTTPS load balancer
             use_auth: Whether instance uses token auth
         """
         # Check if it looks like a UUID (job ID)
         if "-" in instance and len(instance) > 30:
-            job = c3.jobs.get(instance)
+            job = client.jobs.get(instance)
         else:
             # Assume hostname - search running jobs
-            jobs = c3.jobs.list(state="running")
+            jobs = client.jobs.list(state="running")
             job = None
             for j in jobs:
                 if j.hostname and (j.hostname == instance or j.hostname.startswith(instance)):
@@ -789,12 +1021,12 @@ class ComfyUIJob(BaseJob):
             if not job:
                 raise ValueError(f"No running job found with hostname: {instance}")
 
-        return cls(c3, job, use_lb=use_lb, use_auth=use_auth)
+        return cls(client, job, use_lb=use_lb, use_auth=use_auth)
 
     @classmethod
     def get_or_create_for_template(
         cls,
-        c3: "C3",
+        client: "HyperCLI",
         template: str,
         gpu_type: str = None,
         gpu_count: int = 1,
@@ -810,7 +1042,7 @@ class ComfyUIJob(BaseJob):
         (note: the existing job may have different models loaded).
         """
         if reuse:
-            existing = cls.get_running(c3, image_filter=cls.DEFAULT_IMAGE)
+            existing = cls.get_running(client, image_filter=cls.DEFAULT_IMAGE)
             if existing:
                 existing.template = template
                 # TODO: detect lb/auth from existing job's config
@@ -819,7 +1051,7 @@ class ComfyUIJob(BaseJob):
                 return existing
 
         return cls.create_for_template(
-            c3,
+            client,
             template=template,
             gpu_type=gpu_type,
             gpu_count=gpu_count,

{hypercli_sdk-0.4.6 → hypercli_sdk-0.4.7}/hypercli/logs.py

@@ -9,7 +9,7 @@ import websockets
 from .config import get_ws_url, WS_LOGS_PATH
 
 if TYPE_CHECKING:
-    from .client import C3
+    from .client import HyperCLI
 
 
 # Default limits to prevent memory blowup
@@ -17,11 +17,11 @@ DEFAULT_MAX_INITIAL_LINES = 1000  # Max lines to fetch on initial REST call
 DEFAULT_MAX_BUFFER = 5000  # Max lines to keep in memory buffer
 
 
-def fetch_logs(c3: "C3", job_id: str, tail: int = None) -> list[str]:
+def fetch_logs(client: "HyperCLI", job_id: str, tail: int = None) -> list[str]:
     """Fetch logs via REST API (one-time call).
 
     Args:
-        c3: C3 client
+        client: HyperCLI client instance
         job_id: Job ID
         tail: Only return last N lines (default: all)
 
@@ -29,7 +29,7 @@ def fetch_logs(c3: "C3", job_id: str, tail: int = None) -> list[str]:
         List of log lines
     """
     try:
-        logs = c3.jobs.logs(job_id)
+        logs = client.jobs.logs(job_id)
         if not logs:
             return []
         lines = logs.strip().split("\n")
@@ -44,7 +44,7 @@ class LogStream:
     """Async log streamer - websocket streaming with optional initial fetch.
 
     Usage:
-        stream = LogStream(c3, job)
+        stream = LogStream(client, job)
         await stream.connect()
         async for line in stream:
             print(line)
@@ -59,7 +59,7 @@ class LogStream:
 
     def __init__(
         self,
-        c3: "C3",
+        client: "HyperCLI",
         job_id: str,
         job_key: str = None,
         fetch_initial: bool = True,
@@ -68,14 +68,14 @@ class LogStream:
     ):
         """
         Args:
-            c3: C3 client
+            client: HyperCLI client instance
             job_id: Job ID for REST log fetch
             job_key: Job key for websocket (if None, fetched from job)
             fetch_initial: Whether to fetch existing logs on connect
             max_initial_lines: Max lines to fetch initially (prevents huge fetch)
             max_buffer: Max lines to keep in buffer (oldest dropped)
         """
-        self.c3 = c3
+        self.client = client
         self.job_id = job_id
         self.job_key = job_key
         self.fetch_initial = fetch_initial
@@ -112,21 +112,31 @@ class LogStream:
 
         # Fetch initial logs ONCE (bounded)
         if self.fetch_initial and not self._initial_fetched:
-            initial_lines = fetch_logs(self.c3, self.job_id, tail=self.max_initial_lines)
+            initial_lines = fetch_logs(self.client, self.job_id, tail=self.max_initial_lines)
             for line in initial_lines:
                 self._buffer.append(line)
             self._initial_fetched = True
 
         # Get job_key if not provided
         if not self.job_key:
-            job = self.c3.jobs.get(self.job_id)
+            job = self.client.jobs.get(self.job_id)
             self.job_key = job.job_key
 
-        # Connect websocket
+        # Connect websocket with timeout
         if self.job_key and not self._ws:
             ws_url = get_ws_url()
             full_url = f"{ws_url}{WS_LOGS_PATH}/{self.job_key}"
-            self._ws = await websockets.connect(full_url)
+            self._ws = await asyncio.wait_for(
+                websockets.connect(
+                    full_url,
+                    ping_interval=30,
+                    ping_timeout=20,
+                    close_timeout=5,
+                    max_size=2**20,  # 1MB max message size
+                    compression=None,  # Disable compression for lower latency
+                ),
+                timeout=30,
+            )
             self._connected = True
 
         return initial_lines
@@ -181,7 +191,7 @@ class LogStream:
 
 
 async def stream_logs(
-    c3: "C3",
+    client: "HyperCLI",
     job_id: str,
     on_line: Callable[[str], None],
     until_state: set[str] = None,
@@ -193,7 +203,7 @@ async def stream_logs(
     """Stream logs until job reaches a terminal state.
 
     Args:
-        c3: C3 client
+        client: HyperCLI client instance
         job_id: Job ID to stream logs from
         on_line: Callback for each log line (called immediately, no buffering)
         until_state: States to stop on (default: terminal states)
@@ -211,7 +221,7 @@ async def stream_logs(
     if until_state is None:
         until_state = {"succeeded", "failed", "canceled", "terminated"}
 
-    job = c3.jobs.get(job_id)
+    job = client.jobs.get(job_id)
     initial_fetched = False
     ws = None
 
@@ -219,18 +229,18 @@ async def stream_logs(
         # Wait for job to be assigned/running
         while job.state in ("pending", "queued"):
             await asyncio.sleep(poll_state_interval)
-            job = c3.jobs.get(job_id)
+            job = client.jobs.get(job_id)
 
         # Check for immediate terminal state
         if job.state in until_state:
             if fetch_final:
-                for line in fetch_logs(c3, job_id, tail=max_initial_lines):
+                for line in fetch_logs(client, job_id, tail=max_initial_lines):
                     on_line(line)
             return
 
         # Fetch initial logs ONCE when running (bounded)
         if fetch_initial and job.state == "running" and not initial_fetched:
-            for line in fetch_logs(c3, job_id, tail=max_initial_lines):
+            for line in fetch_logs(client, job_id, tail=max_initial_lines):
                 on_line(line)
             initial_fetched = True
 
@@ -255,7 +265,7 @@ async def stream_logs(
                         continue
                 except asyncio.TimeoutError:
                     # Check job state (NOT polling logs!)
-                    job = c3.jobs.get(job_id)
+                    job = client.jobs.get(job_id)
                     if job.state in until_state:
                         break
                 except websockets.ConnectionClosed:
@@ -265,7 +275,7 @@ async def stream_logs(
         if fetch_final:
             # Small delay to let final logs flush
             await asyncio.sleep(0.5)
-            for line in fetch_logs(c3, job_id, tail=max_initial_lines):
+            for line in fetch_logs(client, job_id, tail=max_initial_lines):
                 on_line(line)
 
     finally:

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

@@ -145,7 +145,7 @@ class Renders:
             notify_url: Optional webhook URL for completion notification
 
         Example:
-            render = c3.renders.text_to_image("a cat wearing sunglasses")
+            render = client.renders.text_to_image("a cat wearing sunglasses")
         """
         return self._flow("/api/flow/text-to-image", prompt=prompt, negative=negative, width=width, height=height, notify_url=notify_url)
 
@@ -167,7 +167,7 @@ class Renders:
             notify_url: Optional webhook URL for completion notification
 
         Example:
-            render = c3.renders.text_to_image_hidream("a mystical forest")
+            render = client.renders.text_to_image_hidream("a mystical forest")
         """
         return self._flow("/api/flow/text-to-image-hidream", prompt=prompt, negative=negative, width=width, height=height, notify_url=notify_url)
 
@@ -189,7 +189,7 @@ class Renders:
             notify_url: Optional webhook URL for completion notification
 
         Example:
-            render = c3.renders.text_to_video("a cat walking through a garden")
+            render = client.renders.text_to_video("a cat walking through a garden")
         """
         return self._flow("/api/flow/text-to-video", prompt=prompt, negative=negative, width=width, height=height, notify_url=notify_url)
 
@@ -213,7 +213,7 @@ class Renders:
             notify_url: Optional webhook URL for completion notification
 
         Example:
-            render = c3.renders.image_to_video("dancing", "https://example.com/img.png", width=832, height=480)
+            render = client.renders.image_to_video("dancing", "https://example.com/img.png", width=832, height=480)
         """
         return self._flow("/api/flow/image-to-video", prompt=prompt, image_url=image_url, negative=negative, width=width, height=height, notify_url=notify_url)
 
@@ -239,7 +239,7 @@ class Renders:
             notify_url: Optional webhook URL for completion notification
 
         Example:
-            render = c3.renders.speaking_video(
+            render = client.renders.speaking_video(
                 "A person talking to camera",
                 "https://example.com/face.png",
                 "https://example.com/speech.mp3"
@@ -269,7 +269,7 @@ class Renders:
             notify_url: Optional webhook URL for completion notification
 
         Example:
-            render = c3.renders.speaking_video_wan(
+            render = client.renders.speaking_video_wan(
                 "The person is singing",
                 "https://example.com/face.png",
                 "https://example.com/song.mp3"
@@ -297,7 +297,7 @@ class Renders:
             notify_url: Optional webhook URL for completion notification
 
         Example:
-            render = c3.renders.image_to_image(
+            render = client.renders.image_to_image(
                 "Apply the artistic style from the references",
                 [
                     "https://example.com/subject.jpg",
@@ -330,7 +330,7 @@ class Renders:
             notify_url: Optional webhook URL for completion notification
 
         Example:
-            render = c3.renders.first_last_frame_video(
+            render = client.renders.first_last_frame_video(
                 "smooth transition from day to night",
                 "https://example.com/day.png",
                 "https://example.com/night.png"

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

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