together 2.0.0a18__py3-none-any.whl → 2.0.0a19__py3-none-any.whl

together/_client.py

@@ -45,7 +45,6 @@ if TYPE_CHECKING:
         rerank,
         videos,
         batches,
-        hardware,
         endpoints,
         embeddings,
         completions,
@@ -58,7 +57,6 @@ if TYPE_CHECKING:
     from .resources.rerank import RerankResource, AsyncRerankResource
     from .resources.videos import VideosResource, AsyncVideosResource
     from .resources.batches import BatchesResource, AsyncBatchesResource
-    from .resources.hardware import HardwareResource, AsyncHardwareResource
     from .resources.beta.beta import BetaResource, AsyncBetaResource
     from .resources.chat.chat import ChatResource, AsyncChatResource
     from .resources.endpoints import EndpointsResource, AsyncEndpointsResource
@@ -213,12 +211,6 @@ class Together(SyncAPIClient):
 
         return EndpointsResource(self)
 
-    @cached_property
-    def hardware(self) -> HardwareResource:
-        from .resources.hardware import HardwareResource
-
-        return HardwareResource(self)
-
     @cached_property
     def rerank(self) -> RerankResource:
         from .resources.rerank import RerankResource
@@ -484,12 +476,6 @@ class AsyncTogether(AsyncAPIClient):
 
         return AsyncEndpointsResource(self)
 
-    @cached_property
-    def hardware(self) -> AsyncHardwareResource:
-        from .resources.hardware import AsyncHardwareResource
-
-        return AsyncHardwareResource(self)
-
     @cached_property
     def rerank(self) -> AsyncRerankResource:
         from .resources.rerank import AsyncRerankResource
@@ -701,12 +687,6 @@ class TogetherWithRawResponse:
 
         return EndpointsResourceWithRawResponse(self._client.endpoints)
 
-    @cached_property
-    def hardware(self) -> hardware.HardwareResourceWithRawResponse:
-        from .resources.hardware import HardwareResourceWithRawResponse
-
-        return HardwareResourceWithRawResponse(self._client.hardware)
-
     @cached_property
     def rerank(self) -> rerank.RerankResourceWithRawResponse:
         from .resources.rerank import RerankResourceWithRawResponse
@@ -804,12 +784,6 @@ class AsyncTogetherWithRawResponse:
 
         return AsyncEndpointsResourceWithRawResponse(self._client.endpoints)
 
-    @cached_property
-    def hardware(self) -> hardware.AsyncHardwareResourceWithRawResponse:
-        from .resources.hardware import AsyncHardwareResourceWithRawResponse
-
-        return AsyncHardwareResourceWithRawResponse(self._client.hardware)
-
     @cached_property
     def rerank(self) -> rerank.AsyncRerankResourceWithRawResponse:
         from .resources.rerank import AsyncRerankResourceWithRawResponse
@@ -907,12 +881,6 @@ class TogetherWithStreamedResponse:
 
         return EndpointsResourceWithStreamingResponse(self._client.endpoints)
 
-    @cached_property
-    def hardware(self) -> hardware.HardwareResourceWithStreamingResponse:
-        from .resources.hardware import HardwareResourceWithStreamingResponse
-
-        return HardwareResourceWithStreamingResponse(self._client.hardware)
-
     @cached_property
     def rerank(self) -> rerank.RerankResourceWithStreamingResponse:
         from .resources.rerank import RerankResourceWithStreamingResponse
@@ -1010,12 +978,6 @@ class AsyncTogetherWithStreamedResponse:
 
         return AsyncEndpointsResourceWithStreamingResponse(self._client.endpoints)
 
-    @cached_property
-    def hardware(self) -> hardware.AsyncHardwareResourceWithStreamingResponse:
-        from .resources.hardware import AsyncHardwareResourceWithStreamingResponse
-
-        return AsyncHardwareResourceWithStreamingResponse(self._client.hardware)
-
     @cached_property
     def rerank(self) -> rerank.AsyncRerankResourceWithStreamingResponse:
         from .resources.rerank import AsyncRerankResourceWithStreamingResponse

together/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "together"
-__version__ = "2.0.0-alpha.18"  # x-release-please-version
+__version__ = "2.0.0-alpha.19"  # x-release-please-version

together/lib/cli/api/beta/__init__.py

@@ -1,5 +1,6 @@
 import click
 
+from together.lib.cli.api.beta.jig import jig
 from together.lib.cli.api.beta.clusters import clusters
 
 
@@ -10,3 +11,4 @@ def beta() -> None:
 
 
 beta.add_command(clusters)
+beta.add_command(jig)

together/lib/cli/api/beta/jig/__init__.py

@@ -0,0 +1,52 @@
+"""Jig CLI - deployment tool for Together AI."""
+
+import click
+
+from together.lib.cli.api.beta.jig.jig import (
+    init,
+    logs,
+    push,
+    build,
+    deploy,
+    status,
+    endpoint,
+    submit,
+    destroy,
+    dockerfile,
+    job_status,
+    queue_status,
+    list_deployments,
+)
+from together.lib.cli.api.beta.jig.secrets import secrets
+from together.lib.cli.api.beta.jig.volumes import volumes
+
+
+@click.group()
+@click.pass_context
+def jig(ctx: click.Context) -> None:
+    """Jig commands - deploy and manage containers"""
+    pass
+
+
+def add_commands(parent: click.Group):
+    # Add subgroups
+    parent.add_command(secrets)
+    parent.add_command(volumes)
+
+    # Add main commands
+    parent.add_command(init)
+    parent.add_command(dockerfile)
+    parent.add_command(build)
+    parent.add_command(push)
+    parent.add_command(deploy)
+    parent.add_command(status)
+    parent.add_command(endpoint)
+    parent.add_command(logs)
+    parent.add_command(destroy)
+    parent.add_command(submit)
+    parent.add_command(job_status)
+    parent.add_command(queue_status)
+    parent.add_command(list_deployments)
+
+
+add_commands(jig)

together/lib/cli/api/beta/jig/_config.py

@@ -0,0 +1,170 @@
+"""Configuration and state management for jig CLI."""
+
+from __future__ import annotations
+
+import os
+import sys
+import json
+from typing import TYPE_CHECKING, Any, Optional
+from pathlib import Path
+from dataclasses import field, asdict, dataclass
+
+import click
+
+if TYPE_CHECKING:
+    import tomli as tomllib
+else:
+    try:
+        import tomllib
+    except ImportError:
+        import tomli as tomllib
+
+# --- Environment Configuration ---
+
+DEBUG = os.getenv("TOGETHER_DEBUG", "").strip()[:1] in ("y", "1", "t")
+
+UPLOAD_CONCURRENCY_LIMIT = int(os.getenv("TOGETHER_UPLOAD_CONCURRENCY", "15"))
+MULTIPART_CHUNK_SIZE_MB = int(os.getenv("TOGETHER_MULTIPART_CHUNK_SIZE_MB", "20"))
+MULTIPART_THRESHOLD_MB = int(os.getenv("TOGETHER_MULTIPART_THRESHOLD_MB", "100"))
+MAX_UPLOAD_RETRIES = 3
+
+# Warmup configuration (for torch compile cache)
+WARMUP_ENV_NAME = os.getenv("WARMUP_ENV_NAME", "TORCHINDUCTOR_CACHE_DIR")
+WARMUP_DEST = os.getenv("WARMUP_DEST", "torch_cache")
+
+
+# --- Configuration Dataclasses ---
+
+
+@dataclass
+class ImageConfig:
+    """Container image configuration from pyproject.toml"""
+
+    python_version: str = "3.11"
+    system_packages: list[str] = field(default_factory=list[str])
+    environment: dict[str, str] = field(default_factory=dict[str, str])
+    run: list[str] = field(default_factory=list[str])
+    cmd: str = "python app.py"
+    copy: list[str] = field(default_factory=list[str])
+    auto_include_git: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ImageConfig:
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+
+@dataclass
+class DeployConfig:
+    """Deployment configuration"""
+
+    description: str = ""
+    gpu_type: str = "h100-80gb"
+    gpu_count: int = 1
+    cpu: float = 1
+    memory: float = 8
+    storage: int = 100
+    min_replicas: int = 1
+    max_replicas: int = 1
+    port: int = 8000
+    environment_variables: dict[str, str] = field(default_factory=dict[str, str])
+    command: Optional[list[str]] = None
+    autoscaling: dict[str, str] = field(default_factory=dict[str, str])
+    health_check_path: str = "/health"
+    termination_grace_period_seconds: int = 300
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> DeployConfig:
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+
+@dataclass
+class Config:
+    """Main configuration from jig.toml or pyproject.toml"""
+
+    model_name: str = ""
+    dockerfile: str = "Dockerfile"
+    image: ImageConfig = field(default_factory=ImageConfig)
+    deploy: DeployConfig = field(default_factory=DeployConfig)
+    _path: Path = field(default_factory=lambda: Path("pyproject.toml"))
+
+    @classmethod
+    def find(cls, config_path: Optional[str] = None, init: bool = False) -> Config:
+        """Find specified config_path, pyproject.toml, or jig.toml"""
+        if config_path:
+            found_path = Path(config_path)
+            if not found_path.exists():
+                click.echo(f"ERROR: Configuration file not found: {config_path}", err=True)
+                sys.exit(1)
+            return cls.load(tomllib.load(found_path.open("rb")), found_path)
+
+        if (jigfile := Path("jig.toml")).exists():
+            return cls.load(tomllib.load(jigfile.open("rb")), jigfile)
+
+        if (pyproject_path := Path("pyproject.toml")).exists():
+            data = tomllib.load(pyproject_path.open("rb"))
+            if "tool" in data and "jig" in data["tool"]:
+                return cls.load(data, pyproject_path)
+
+        if init:
+            return cls()
+        click.echo(
+            "ERROR: No pyproject.toml or jig.toml found, use --config to specify a config path.",
+            err=True,
+        )
+        sys.exit(1)
+
+    @classmethod
+    def load(cls, data: dict[str, Any], path: Path) -> Config:
+        """Load configuration from parsed TOML data"""
+        is_pyproject = path.name == "pyproject.toml"
+
+        jig_config = data.get("tool", {}).get("jig", {}) if is_pyproject else data
+
+        name = jig_config.get("name")
+        if name is None:
+            if is_pyproject:
+                name = data.get("project", {}).get("name", "")
+            else:
+                name = path.resolve().parent.name
+                click.echo(f"\N{PACKAGE} Name not set in config file or pyproject.toml - defaulting to {name}")
+
+        if autoscaling := jig_config.get("autoscaling", {}):
+            autoscaling["model"] = name
+            jig_config["deploy"]["autoscaling"] = autoscaling
+
+        return cls(
+            image=ImageConfig.from_dict(jig_config.get("image", {})),
+            deploy=DeployConfig.from_dict(jig_config.get("deploy", {})),
+            dockerfile=jig_config.get("dockerfile", "Dockerfile"),
+            model_name=name,
+            _path=path,
+        )
+
+
+# --- State Management ---
+
+
+@dataclass
+class State:
+    """Persistent state stored in .jig.json"""
+
+    _config_dir: Path
+    registry_base_path: str = ""
+    secrets: dict[str, str] = field(default_factory=dict[str, str])
+    volumes: dict[str, str] = field(default_factory=dict[str, str])
+
+    @classmethod
+    def load(cls, config_dir: Path) -> State:
+        path = config_dir / ".jig.json"
+        try:
+            with open(path) as f:
+                data = {k: v for k, v in json.load(f).items() if k in cls.__annotations__ and not k.startswith("_")}
+                return cls(_config_dir=config_dir, **data)
+        except FileNotFoundError:
+            return cls(_config_dir=config_dir)
+
+    def save(self) -> None:
+        path = self._config_dir / ".jig.json"
+        data = {k: v for k, v in asdict(self).items() if not k.startswith("_")}
+        with open(path, "w") as f:
+            json.dump(data, f, indent=2)