together 2.0.0a9__py3-none-any.whl → 2.0.0a10__py3-none-any.whl

together/_types.py

@@ -243,6 +243,9 @@ _T_co = TypeVar("_T_co", covariant=True)
 if TYPE_CHECKING:
     # This works because str.__contains__ does not accept object (either in typeshed or at runtime)
     # https://github.com/hauntsaninja/useful_types/blob/5e9710f3875107d068e7679fd7fec9cfab0eff3b/useful_types/__init__.py#L285
+    #
+    # Note: index() and count() methods are intentionally omitted to allow pyright to properly
+    # infer TypedDict types when dict literals are used in lists assigned to SequenceNotStr.
     class SequenceNotStr(Protocol[_T_co]):
         @overload
         def __getitem__(self, index: SupportsIndex, /) -> _T_co: ...
@@ -251,8 +254,6 @@ if TYPE_CHECKING:
         def __contains__(self, value: object, /) -> bool: ...
         def __len__(self) -> int: ...
         def __iter__(self) -> Iterator[_T_co]: ...
-        def index(self, value: Any, start: int = 0, stop: int = ..., /) -> int: ...
-        def count(self, value: Any, /) -> int: ...
         def __reversed__(self) -> Iterator[_T_co]: ...
 else:
     # just point this to a normal `Sequence` at runtime to avoid having to special case

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.9"  # x-release-please-version
+__version__ = "2.0.0-alpha.10"  # x-release-please-version

together/lib/cli/api/fine_tuning.py

@@ -13,6 +13,7 @@ from tabulate import tabulate
 from click.core import ParameterSource  # type: ignore[attr-defined]
 
 from together import Together
+from together.types import fine_tuning_estimate_price_params as pe_params
 from together._types import NOT_GIVEN, NotGiven
 from together.lib.utils import log_warn
 from together.lib.utils.tools import format_timestamp, finetune_price_to_dollars
@@ -24,13 +25,21 @@ from together.lib.resources.fine_tuning import get_model_limits
 
 _CONFIRMATION_MESSAGE = (
     "You are about to create a fine-tuning job. "
-    "The cost of your job will be determined by the model size, the number of tokens "
+    "The estimated price of this job is {price}. "
+    "The actual cost of your job will be determined by the model size, the number of tokens "
     "in the training file, the number of tokens in the validation file, the number of epochs, and "
-    "the number of evaluations. Visit https://www.together.ai/pricing to get a price estimate.\n"
+    "the number of evaluations. Visit https://www.together.ai/pricing to learn more about pricing.\n"
+    "{warning}"
     "You can pass `-y` or `--confirm` to your command to skip this message.\n\n"
     "Do you want to proceed?"
 )
 
+_WARNING_MESSAGE_INSUFFICIENT_FUNDS = (
+    "The estimated price of this job is significantly greater than your current credit limit and balance combined. "
+    "It will likely get cancelled due to insufficient funds. "
+    "Consider increasing your credit limit at https://api.together.xyz/settings/profile\n"
+)
+
 _FT_JOB_WITH_STEP_REGEX = r"^ft-[\dabcdef-]+:\d+$"
 
 
@@ -323,7 +332,60 @@ def create(
     elif n_evals > 0 and not validation_file:
         raise click.BadParameter("You have specified a number of evaluation loops but no validation file.")
 
-    if confirm or click.confirm(_CONFIRMATION_MESSAGE, default=True, show_default=True):
+    training_type_cls: pe_params.TrainingType
+    if lora:
+        training_type_cls = pe_params.TrainingTypeLoRaTrainingType(
+            lora_alpha=int(lora_alpha or 0),
+            lora_r=lora_r or 0,
+            lora_dropout=lora_dropout or 0,
+            lora_trainable_modules=lora_trainable_modules or "all-linear",
+            type="Lora",
+        )
+    else:
+        training_type_cls = pe_params.TrainingTypeFullTrainingType(
+            type="Full",
+        )
+
+    training_method_cls: pe_params.TrainingMethod
+    if training_method == "sft":
+        training_method_cls = pe_params.TrainingMethodTrainingMethodSft(
+            method="sft",
+            train_on_inputs=train_on_inputs or "auto",
+        )
+    else:
+        training_method_cls = pe_params.TrainingMethodTrainingMethodDpo(
+            method="dpo",
+            dpo_beta=dpo_beta or 0,
+            dpo_normalize_logratios_by_length=dpo_normalize_logratios_by_length or False,
+            dpo_reference_free=False,
+            rpo_alpha=rpo_alpha or 0,
+            simpo_gamma=simpo_gamma or 0,
+        )
+    
+    finetune_price_estimation_result = client.fine_tuning.estimate_price(
+        training_file=training_file,
+        validation_file=validation_file,
+        model=model or "",
+        n_epochs=n_epochs,
+        n_evals=n_evals,
+        training_type=training_type_cls,
+        training_method=training_method_cls,
+    )
+    price = click.style(
+        f"${finetune_price_estimation_result.estimated_total_price:.2f}",
+        bold=True,
+    )
+    if not finetune_price_estimation_result.allowed_to_proceed:
+        warning = click.style(_WARNING_MESSAGE_INSUFFICIENT_FUNDS, fg="red", bold=True)
+    else:
+        warning = ""
+
+    confirmation_message = _CONFIRMATION_MESSAGE.format(
+        price=price,
+        warning=warning,
+    )
+
+    if confirm or click.confirm(confirmation_message, default=True, show_default=True):
         response = client.fine_tuning.create(
             **training_args,
             verbose=True,

together/lib/cli/api/models.py

@@ -7,7 +7,6 @@ from tabulate import tabulate
 from together import Together, omit
 from together._models import BaseModel
 from together._response import APIResponse as APIResponse
-from together.lib.resources.models import filter_by_dedicated_models
 from together.types.model_upload_response import ModelUploadResponse
 
 
@@ -34,11 +33,7 @@ def list(ctx: click.Context, type: Optional[str], json: bool) -> None:
     """List models"""
     client: Together = ctx.obj
 
-    response = client.models.list()
-    models_list = response
-
-    if type == "dedicated":
-        models_list = filter_by_dedicated_models(client, models_list)
+    models_list = client.models.list(dedicated=type == "dedicated" if type else omit)
 
     display_list: List[Dict[str, Any]] = []
     model: BaseModel

together/lib/resources/fine_tuning.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Literal
 
 from rich import print as rprint
 
+from together.types import fine_tuning_estimate_price_params as pe_params
 from together.lib.utils import log_warn_once
 
 if TYPE_CHECKING:
@@ -66,7 +67,7 @@ def create_finetune_request(
     hf_model_revision: str | None = None,
     hf_api_token: str | None = None,
     hf_output_repo_name: str | None = None,
-) -> FinetuneRequest:
+) -> tuple[FinetuneRequest, pe_params.TrainingType, pe_params.TrainingMethod]:
     if model is not None and from_checkpoint is not None:
         raise ValueError("You must specify either a model or a checkpoint to start a job from, not both")
 
@@ -233,8 +234,46 @@ def create_finetune_request(
         hf_output_repo_name=hf_output_repo_name,
     )
 
-    return finetune_request
+    training_type_pe, training_method_pe = create_price_estimation_params(finetune_request)
 
+    return finetune_request, training_type_pe, training_method_pe
+
+def create_price_estimation_params(finetune_request: FinetuneRequest) -> tuple[pe_params.TrainingType, pe_params.TrainingMethod]:
+    training_type_cls: pe_params.TrainingType
+    if isinstance(finetune_request.training_type, FullTrainingType):
+        training_type_cls = pe_params.TrainingTypeFullTrainingType(
+            type="Full",
+        )
+    elif isinstance(finetune_request.training_type, LoRATrainingType):
+        training_type_cls = pe_params.TrainingTypeLoRaTrainingType(
+            lora_alpha=finetune_request.training_type.lora_alpha,
+            lora_r=finetune_request.training_type.lora_r,
+            lora_dropout=finetune_request.training_type.lora_dropout,
+            lora_trainable_modules=finetune_request.training_type.lora_trainable_modules,
+            type="Lora",
+        )
+    else:
+        raise ValueError(f"Unknown training type: {finetune_request.training_type}")
+
+    training_method_cls: pe_params.TrainingMethod
+    if isinstance(finetune_request.training_method, TrainingMethodSFT):
+        training_method_cls = pe_params.TrainingMethodTrainingMethodSft(
+            method="sft",
+            train_on_inputs=finetune_request.training_method.train_on_inputs,
+        )
+    elif isinstance(finetune_request.training_method, TrainingMethodDPO):
+        training_method_cls = pe_params.TrainingMethodTrainingMethodDpo(
+            method="dpo",
+            dpo_beta=finetune_request.training_method.dpo_beta or 0,
+            dpo_normalize_logratios_by_length=finetune_request.training_method.dpo_normalize_logratios_by_length,
+            dpo_reference_free=finetune_request.training_method.dpo_reference_free,
+            rpo_alpha=finetune_request.training_method.rpo_alpha or 0,
+            simpo_gamma=finetune_request.training_method.simpo_gamma or 0,
+        )
+    else:
+        raise ValueError(f"Unknown training method: {finetune_request.training_method}")
+
+    return training_type_cls, training_method_cls
 
 def get_model_limits(client: Together, model: str) -> FinetuneTrainingLimits:
     """

together/resources/chat/completions.py

@@ -136,6 +136,14 @@ class CompletionsResource(SyncAPIResource):
 
           response_format: An object specifying the format that the model must output.
 
+              Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
+              Outputs which ensures the model will match your supplied JSON schema. Learn more
+              in the [Structured Outputs guide](https://docs.together.ai/docs/json-mode).
+
+              Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+              ensures the message the model generates is valid JSON. Using `json_schema` is
+              preferred for models that support it.
+
           safety_model: The name of the moderation model used to validate tokens. Choose from the
               available moderation models found
               [here](https://docs.together.ai/docs/inference-models#moderation-models).
@@ -277,6 +285,14 @@ class CompletionsResource(SyncAPIResource):
 
           response_format: An object specifying the format that the model must output.
 
+              Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
+              Outputs which ensures the model will match your supplied JSON schema. Learn more
+              in the [Structured Outputs guide](https://docs.together.ai/docs/json-mode).
+
+              Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+              ensures the message the model generates is valid JSON. Using `json_schema` is
+              preferred for models that support it.
+
           safety_model: The name of the moderation model used to validate tokens. Choose from the
               available moderation models found
               [here](https://docs.together.ai/docs/inference-models#moderation-models).
@@ -414,6 +430,14 @@ class CompletionsResource(SyncAPIResource):
 
           response_format: An object specifying the format that the model must output.
 
+              Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
+              Outputs which ensures the model will match your supplied JSON schema. Learn more
+              in the [Structured Outputs guide](https://docs.together.ai/docs/json-mode).
+
+              Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+              ensures the message the model generates is valid JSON. Using `json_schema` is
+              preferred for models that support it.
+
           safety_model: The name of the moderation model used to validate tokens. Choose from the
               available moderation models found
               [here](https://docs.together.ai/docs/inference-models#moderation-models).
@@ -653,6 +677,14 @@ class AsyncCompletionsResource(AsyncAPIResource):
 
           response_format: An object specifying the format that the model must output.
 
+              Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
+              Outputs which ensures the model will match your supplied JSON schema. Learn more
+              in the [Structured Outputs guide](https://docs.together.ai/docs/json-mode).
+
+              Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+              ensures the message the model generates is valid JSON. Using `json_schema` is
+              preferred for models that support it.
+
           safety_model: The name of the moderation model used to validate tokens. Choose from the
               available moderation models found
               [here](https://docs.together.ai/docs/inference-models#moderation-models).
@@ -794,6 +826,14 @@ class AsyncCompletionsResource(AsyncAPIResource):
 
           response_format: An object specifying the format that the model must output.
 
+              Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
+              Outputs which ensures the model will match your supplied JSON schema. Learn more
+              in the [Structured Outputs guide](https://docs.together.ai/docs/json-mode).
+
+              Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+              ensures the message the model generates is valid JSON. Using `json_schema` is
+              preferred for models that support it.
+
           safety_model: The name of the moderation model used to validate tokens. Choose from the
               available moderation models found
               [here](https://docs.together.ai/docs/inference-models#moderation-models).
@@ -931,6 +971,14 @@ class AsyncCompletionsResource(AsyncAPIResource):
 
           response_format: An object specifying the format that the model must output.
 
+              Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
+              Outputs which ensures the model will match your supplied JSON schema. Learn more
+              in the [Structured Outputs guide](https://docs.together.ai/docs/json-mode).
+
+              Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+              ensures the message the model generates is valid JSON. Using `json_schema` is
+              preferred for models that support it.
+
           safety_model: The name of the moderation model used to validate tokens. Choose from the
               available moderation models found
               [here](https://docs.together.ai/docs/inference-models#moderation-models).

together/resources/fine_tuning.py

@@ -7,7 +7,7 @@ from typing_extensions import Literal
 import httpx
 from rich import print as rprint
 
-from ..types import fine_tuning_delete_params, fine_tuning_content_params
+from ..types import fine_tuning_delete_params, fine_tuning_content_params, fine_tuning_estimate_price_params
 from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
@@ -27,17 +27,31 @@ from .._response import (
     async_to_custom_streamed_response_wrapper,
 )
 from .._base_client import make_request_options
-from ..lib.types.fine_tuning import FinetuneResponse as FinetuneResponseLib, FinetuneTrainingLimits
+from ..lib.types.fine_tuning import (
+    FinetuneResponse as FinetuneResponseLib,
+    FinetuneTrainingLimits,
+)
 from ..types.finetune_response import FinetuneResponse
-from ..lib.resources.fine_tuning import get_model_limits, async_get_model_limits, create_finetune_request
+from ..lib.resources.fine_tuning import (
+    get_model_limits,
+    async_get_model_limits,
+    create_finetune_request,
+)
 from ..types.fine_tuning_list_response import FineTuningListResponse
 from ..types.fine_tuning_cancel_response import FineTuningCancelResponse
 from ..types.fine_tuning_delete_response import FineTuningDeleteResponse
 from ..types.fine_tuning_list_events_response import FineTuningListEventsResponse
+from ..types.fine_tuning_estimate_price_response import FineTuningEstimatePriceResponse
 from ..types.fine_tuning_list_checkpoints_response import FineTuningListCheckpointsResponse
 
 __all__ = ["FineTuningResource", "AsyncFineTuningResource"]
 
+_WARNING_MESSAGE_INSUFFICIENT_FUNDS = (
+    "The estimated price of the fine-tuning job is {} which is significantly "
+    "greater than your current credit limit and balance combined. "
+    "It will likely get cancelled due to insufficient funds. "
+    "Proceed at your own risk."
+)
 
 class FineTuningResource(SyncAPIResource):
     @cached_property
@@ -179,7 +193,7 @@ class FineTuningResource(SyncAPIResource):
                 pass
             model_limits = get_model_limits(self._client, str(model_name))
 
-        finetune_request = create_finetune_request(
+        finetune_request, training_type_cls, training_method_cls = create_finetune_request(
             model_limits=model_limits,
             training_file=training_file,
             model=model,
@@ -218,11 +232,32 @@ class FineTuningResource(SyncAPIResource):
             hf_output_repo_name=hf_output_repo_name,
         )
 
+
+        price_estimation_result = self.estimate_price(
+            training_file=training_file,
+            from_checkpoint=from_checkpoint or Omit(),
+            validation_file=validation_file or Omit(),
+            model=model or "",
+            n_epochs=finetune_request.n_epochs,
+            n_evals=finetune_request.n_evals or 0,
+            training_type=training_type_cls,
+            training_method=training_method_cls,
+        )
+
+
         if verbose:
             rprint(
                 "Submitting a fine-tuning job with the following parameters:",
                 finetune_request,
             )
+            if not price_estimation_result.allowed_to_proceed:
+                rprint(
+                    "[red]"
+                    + _WARNING_MESSAGE_INSUFFICIENT_FUNDS.format(
+                        price_estimation_result.estimated_total_price # pyright: ignore[reportPossiblyUnboundVariable]
+                    )
+                    + "[/red]",
+                )
         parameter_payload = finetune_request.model_dump(exclude_none=True)
 
         return self._client.post(
@@ -413,6 +448,76 @@ class FineTuningResource(SyncAPIResource):
             cast_to=BinaryAPIResponse,
         )
 
+    def estimate_price(
+        self,
+        *,
+        training_file: str,
+        from_checkpoint: str | Omit = omit,
+        model: str | Omit = omit,
+        n_epochs: int | Omit = omit,
+        n_evals: int | Omit = omit,
+        training_method: fine_tuning_estimate_price_params.TrainingMethod | Omit = omit,
+        training_type: fine_tuning_estimate_price_params.TrainingType | Omit = omit,
+        validation_file: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FineTuningEstimatePriceResponse:
+        """
+        Estimate the price of a fine-tuning job.
+
+        Args:
+          training_file: File-ID of a training file uploaded to the Together API
+
+          from_checkpoint: The checkpoint identifier to continue training from a previous fine-tuning job.
+              Format is `{$JOB_ID}` or `{$OUTPUT_MODEL_NAME}` or `{$JOB_ID}:{$STEP}` or
+              `{$OUTPUT_MODEL_NAME}:{$STEP}`. The step value is optional; without it, the
+              final checkpoint will be used.
+
+          model: Name of the base model to run fine-tune job on
+
+          n_epochs: Number of complete passes through the training dataset (higher values may
+              improve results but increase cost and risk of overfitting)
+
+          n_evals: Number of evaluations to be run on a given validation set during training
+
+          training_method: The training method to use. 'sft' for Supervised Fine-Tuning or 'dpo' for Direct
+              Preference Optimization.
+
+          validation_file: File-ID of a validation file uploaded to the Together API
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/fine-tunes/estimate-price",
+            body=maybe_transform(
+                {
+                    "training_file": training_file,
+                    "from_checkpoint": from_checkpoint,
+                    "model": model,
+                    "n_epochs": n_epochs,
+                    "n_evals": n_evals,
+                    "training_method": training_method,
+                    "training_type": training_type,
+                    "validation_file": validation_file,
+                },
+                fine_tuning_estimate_price_params.FineTuningEstimatePriceParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FineTuningEstimatePriceResponse,
+        )
+
     def list_checkpoints(
         self,
         id: str,
@@ -620,7 +725,7 @@ class AsyncFineTuningResource(AsyncAPIResource):
                 pass
             model_limits = await async_get_model_limits(self._client, str(model_name))
 
-        finetune_request = create_finetune_request(
+        finetune_request, training_type_cls, training_method_cls = create_finetune_request(
             model_limits=model_limits,
             training_file=training_file,
             model=model,
@@ -659,11 +764,32 @@ class AsyncFineTuningResource(AsyncAPIResource):
             hf_output_repo_name=hf_output_repo_name,
         )
 
+
+        price_estimation_result = await self.estimate_price(
+            training_file=training_file,
+            from_checkpoint=from_checkpoint or Omit(),
+            validation_file=validation_file or Omit(),
+            model=model or "",
+            n_epochs=finetune_request.n_epochs,
+            n_evals=finetune_request.n_evals or 0,
+            training_type=training_type_cls,
+            training_method=training_method_cls,
+        )
+
+
         if verbose:
             rprint(
                 "Submitting a fine-tuning job with the following parameters:",
                 finetune_request,
             )
+            if not price_estimation_result.allowed_to_proceed:
+                rprint(
+                    "[red]"
+                    + _WARNING_MESSAGE_INSUFFICIENT_FUNDS.format(
+                        price_estimation_result.estimated_total_price # pyright: ignore[reportPossiblyUnboundVariable]
+                    )
+                    + "[/red]",
+                )
         parameter_payload = finetune_request.model_dump(exclude_none=True)
 
         return await self._client.post(
@@ -854,6 +980,76 @@ class AsyncFineTuningResource(AsyncAPIResource):
             cast_to=AsyncBinaryAPIResponse,
         )
 
+    async def estimate_price(
+        self,
+        *,
+        training_file: str,
+        from_checkpoint: str | Omit = omit,
+        model: str | Omit = omit,
+        n_epochs: int | Omit = omit,
+        n_evals: int | Omit = omit,
+        training_method: fine_tuning_estimate_price_params.TrainingMethod | Omit = omit,
+        training_type: fine_tuning_estimate_price_params.TrainingType | Omit = omit,
+        validation_file: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FineTuningEstimatePriceResponse:
+        """
+        Estimate the price of a fine-tuning job.
+
+        Args:
+          training_file: File-ID of a training file uploaded to the Together API
+
+          from_checkpoint: The checkpoint identifier to continue training from a previous fine-tuning job.
+              Format is `{$JOB_ID}` or `{$OUTPUT_MODEL_NAME}` or `{$JOB_ID}:{$STEP}` or
+              `{$OUTPUT_MODEL_NAME}:{$STEP}`. The step value is optional; without it, the
+              final checkpoint will be used.
+
+          model: Name of the base model to run fine-tune job on
+
+          n_epochs: Number of complete passes through the training dataset (higher values may
+              improve results but increase cost and risk of overfitting)
+
+          n_evals: Number of evaluations to be run on a given validation set during training
+
+          training_method: The training method to use. 'sft' for Supervised Fine-Tuning or 'dpo' for Direct
+              Preference Optimization.
+
+          validation_file: File-ID of a validation file uploaded to the Together API
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/fine-tunes/estimate-price",
+            body=await async_maybe_transform(
+                {
+                    "training_file": training_file,
+                    "from_checkpoint": from_checkpoint,
+                    "model": model,
+                    "n_epochs": n_epochs,
+                    "n_evals": n_evals,
+                    "training_method": training_method,
+                    "training_type": training_type,
+                    "validation_file": validation_file,
+                },
+                fine_tuning_estimate_price_params.FineTuningEstimatePriceParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FineTuningEstimatePriceResponse,
+        )
+
     async def list_checkpoints(
         self,
         id: str,
@@ -941,6 +1137,9 @@ class FineTuningResourceWithRawResponse:
             fine_tuning.content,
             BinaryAPIResponse,
         )
+        self.estimate_price = to_raw_response_wrapper(
+            fine_tuning.estimate_price,
+        )
         self.list_checkpoints = to_raw_response_wrapper(
             fine_tuning.list_checkpoints,
         )
@@ -969,6 +1168,9 @@ class AsyncFineTuningResourceWithRawResponse:
             fine_tuning.content,
             AsyncBinaryAPIResponse,
         )
+        self.estimate_price = async_to_raw_response_wrapper(
+            fine_tuning.estimate_price,
+        )
         self.list_checkpoints = async_to_raw_response_wrapper(
             fine_tuning.list_checkpoints,
         )
@@ -997,6 +1199,9 @@ class FineTuningResourceWithStreamingResponse:
             fine_tuning.content,
             StreamedBinaryAPIResponse,
         )
+        self.estimate_price = to_streamed_response_wrapper(
+            fine_tuning.estimate_price,
+        )
         self.list_checkpoints = to_streamed_response_wrapper(
             fine_tuning.list_checkpoints,
         )
@@ -1025,6 +1230,9 @@ class AsyncFineTuningResourceWithStreamingResponse:
             fine_tuning.content,
             AsyncStreamedBinaryAPIResponse,
         )
+        self.estimate_price = async_to_streamed_response_wrapper(
+            fine_tuning.estimate_price,
+        )
         self.list_checkpoints = async_to_streamed_response_wrapper(
             fine_tuning.list_checkpoints,
         )