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

together/_base_client.py

@@ -86,6 +86,7 @@ from ._exceptions import (
     APIConnectionError,
     APIResponseValidationError,
 )
+from ._utils._json import openapi_dumps
 
 log: logging.Logger = logging.getLogger(__name__)
 
@@ -554,8 +555,10 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
                 kwargs["content"] = options.content
             elif isinstance(json_data, bytes):
                 kwargs["content"] = json_data
-            else:
-                kwargs["json"] = json_data if is_given(json_data) else None
+            elif not files:
+                # Don't set content when JSON is sent as multipart/form-data,
+                # since httpx's content param overrides other body arguments
+                kwargs["content"] = openapi_dumps(json_data) if is_given(json_data) and json_data is not None else None
             kwargs["files"] = files
         else:
             headers.pop("Content-Type", None)

together/_client.py

@@ -37,7 +37,6 @@ if TYPE_CHECKING:
     from .resources import (
         beta,
         chat,
-        jobs,
         audio,
         evals,
         files,
@@ -46,22 +45,18 @@ if TYPE_CHECKING:
         rerank,
         videos,
         batches,
-        hardware,
         endpoints,
         embeddings,
         completions,
         fine_tuning,
         code_interpreter,
     )
-    from .resources.jobs import JobsResource, AsyncJobsResource
     from .resources.evals import EvalsResource, AsyncEvalsResource
     from .resources.files import FilesResource, AsyncFilesResource
     from .resources.images import ImagesResource, AsyncImagesResource
-    from .resources.models import ModelsResource, AsyncModelsResource
     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
@@ -69,6 +64,7 @@ if TYPE_CHECKING:
     from .resources.audio.audio import AudioResource, AsyncAudioResource
     from .resources.completions import CompletionsResource, AsyncCompletionsResource
     from .resources.fine_tuning import FineTuningResource, AsyncFineTuningResource
+    from .resources.models.models import ModelsResource, AsyncModelsResource
     from .resources.code_interpreter.code_interpreter import CodeInterpreterResource, AsyncCodeInterpreterResource
 
 __all__ = [
@@ -209,24 +205,12 @@ class Together(SyncAPIClient):
 
         return ModelsResource(self)
 
-    @cached_property
-    def jobs(self) -> JobsResource:
-        from .resources.jobs import JobsResource
-
-        return JobsResource(self)
-
     @cached_property
     def endpoints(self) -> EndpointsResource:
         from .resources.endpoints import EndpointsResource
 
         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
@@ -486,24 +470,12 @@ class AsyncTogether(AsyncAPIClient):
 
         return AsyncModelsResource(self)
 
-    @cached_property
-    def jobs(self) -> AsyncJobsResource:
-        from .resources.jobs import AsyncJobsResource
-
-        return AsyncJobsResource(self)
-
     @cached_property
     def endpoints(self) -> AsyncEndpointsResource:
         from .resources.endpoints import AsyncEndpointsResource
 
         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
@@ -709,24 +681,12 @@ class TogetherWithRawResponse:
 
         return ModelsResourceWithRawResponse(self._client.models)
 
-    @cached_property
-    def jobs(self) -> jobs.JobsResourceWithRawResponse:
-        from .resources.jobs import JobsResourceWithRawResponse
-
-        return JobsResourceWithRawResponse(self._client.jobs)
-
     @cached_property
     def endpoints(self) -> endpoints.EndpointsResourceWithRawResponse:
         from .resources.endpoints import EndpointsResourceWithRawResponse
 
         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
@@ -818,24 +778,12 @@ class AsyncTogetherWithRawResponse:
 
         return AsyncModelsResourceWithRawResponse(self._client.models)
 
-    @cached_property
-    def jobs(self) -> jobs.AsyncJobsResourceWithRawResponse:
-        from .resources.jobs import AsyncJobsResourceWithRawResponse
-
-        return AsyncJobsResourceWithRawResponse(self._client.jobs)
-
     @cached_property
     def endpoints(self) -> endpoints.AsyncEndpointsResourceWithRawResponse:
         from .resources.endpoints import AsyncEndpointsResourceWithRawResponse
 
         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
@@ -927,24 +875,12 @@ class TogetherWithStreamedResponse:
 
         return ModelsResourceWithStreamingResponse(self._client.models)
 
-    @cached_property
-    def jobs(self) -> jobs.JobsResourceWithStreamingResponse:
-        from .resources.jobs import JobsResourceWithStreamingResponse
-
-        return JobsResourceWithStreamingResponse(self._client.jobs)
-
     @cached_property
     def endpoints(self) -> endpoints.EndpointsResourceWithStreamingResponse:
         from .resources.endpoints import EndpointsResourceWithStreamingResponse
 
         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
@@ -1036,24 +972,12 @@ class AsyncTogetherWithStreamedResponse:
 
         return AsyncModelsResourceWithStreamingResponse(self._client.models)
 
-    @cached_property
-    def jobs(self) -> jobs.AsyncJobsResourceWithStreamingResponse:
-        from .resources.jobs import AsyncJobsResourceWithStreamingResponse
-
-        return AsyncJobsResourceWithStreamingResponse(self._client.jobs)
-
     @cached_property
     def endpoints(self) -> endpoints.AsyncEndpointsResourceWithStreamingResponse:
         from .resources.endpoints import AsyncEndpointsResourceWithStreamingResponse
 
         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/_compat.py

@@ -139,6 +139,7 @@ def model_dump(
     exclude_defaults: bool = False,
     warnings: bool = True,
     mode: Literal["json", "python"] = "python",
+    by_alias: bool | None = None,
 ) -> dict[str, Any]:
     if (not PYDANTIC_V1) or hasattr(model, "model_dump"):
         return model.model_dump(
@@ -148,13 +149,12 @@ def model_dump(
             exclude_defaults=exclude_defaults,
             # warnings are not supported in Pydantic v1
             warnings=True if PYDANTIC_V1 else warnings,
+            by_alias=by_alias,
         )
     return cast(
         "dict[str, Any]",
         model.dict(  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
-            exclude=exclude,
-            exclude_unset=exclude_unset,
-            exclude_defaults=exclude_defaults,
+            exclude=exclude, exclude_unset=exclude_unset, exclude_defaults=exclude_defaults, by_alias=bool(by_alias)
         ),
     )
 

together/_utils/_json.py

@@ -0,0 +1,35 @@
+import json
+from typing import Any
+from datetime import datetime
+from typing_extensions import override
+
+import pydantic
+
+from .._compat import model_dump
+
+
+def openapi_dumps(obj: Any) -> bytes:
+    """
+    Serialize an object to UTF-8 encoded JSON bytes.
+
+    Extends the standard json.dumps with support for additional types
+    commonly used in the SDK, such as `datetime`, `pydantic.BaseModel`, etc.
+    """
+    return json.dumps(
+        obj,
+        cls=_CustomEncoder,
+        # Uses the same defaults as httpx's JSON serialization
+        ensure_ascii=False,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode()
+
+
+class _CustomEncoder(json.JSONEncoder):
+    @override
+    def default(self, o: Any) -> Any:
+        if isinstance(o, datetime):
+            return o.isoformat()
+        if isinstance(o, pydantic.BaseModel):
+            return model_dump(o, exclude_unset=True, mode="json", by_alias=True)
+        return super().default(o)

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.17"  # 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)