From bc26160c89817a985770608912b565e40127da73 Mon Sep 17 00:00:00 2001 From: Ben Kazemi Date: Thu, 20 Nov 2025 09:07:04 -0800 Subject: [PATCH] feat: GenAI SDK client(multimodal) - Support Assess Tuning Resource for multimodal dataset. PiperOrigin-RevId: 834786331 --- .../replays/test_assess_multimodal_dataset.py | 116 +++++++ vertexai/_genai/datasets.py | 308 ++++++++++++++++++ vertexai/_genai/types/__init__.py | 50 +++ vertexai/_genai/types/common.py | 237 ++++++++++++++ 4 files changed, 711 insertions(+) create mode 100644 tests/unit/vertexai/genai/replays/test_assess_multimodal_dataset.py diff --git a/tests/unit/vertexai/genai/replays/test_assess_multimodal_dataset.py b/tests/unit/vertexai/genai/replays/test_assess_multimodal_dataset.py new file mode 100644 index 0000000000..673a3b5b68 --- /dev/null +++ b/tests/unit/vertexai/genai/replays/test_assess_multimodal_dataset.py @@ -0,0 +1,116 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# pylint: disable=protected-access,bad-continuation,missing-function-docstring + +from tests.unit.vertexai.genai.replays import pytest_helper +from vertexai._genai import types + +import pytest + +METADATA_SCHEMA_URI = ( + "gs://google-cloud-aiplatform/schema/dataset/metadata/multimodal_1.0.0.yaml" +) +BIGQUERY_TABLE_NAME = "vertex-sdk-dev.multimodal_dataset.test-table" +DATASET = "8810841321427173376" + + +def test_assess_dataset(client): + operation = client.datasets._assess_multimodal_dataset( + name=DATASET, + tuning_resource_usage_assessment_config=types.TuningResourceUsageAssessmentConfig( + model_name="gemini-2.5-flash-001" + ), + gemini_request_read_config=types.GeminiRequestReadConfig( + template_config=types.GeminiTemplateConfig( + gemini_example=types.GeminiExample( + contents=[ + { + "role": "user", + "parts": [{"text": "What is the capital of {name}?"}], + } + ], + ), + ), + ), + ) + assert isinstance(operation, types.MultimodalDatasetOperation) + + +def test_assess_tuning_resources(client): + response = client.datasets.assess_tuning_resources( + dataset_name=DATASET, + model_name="gemini-2.5-flash-001", + template_config=types.GeminiTemplateConfig( + gemini_example=types.GeminiExample( + contents=[ + { + "role": "user", + "parts": [{"text": "What is the capital of {name}?"}], + } + ], + ), + ), + ) + assert isinstance(response, types.TuningResourceUsageAssessmentResult) + + +pytestmark = pytest_helper.setup( + file=__file__, + globals_for_file=globals(), +) + +pytest_plugins = ("pytest_asyncio",) + + +@pytest.mark.asyncio +async def test_assess_dataset_async(client): + operation = await client.aio.datasets._assess_multimodal_dataset( + name=DATASET, + tuning_resource_usage_assessment_config=types.TuningResourceUsageAssessmentConfig( + model_name="gemini-2.5-flash-001" + ), + gemini_request_read_config=types.GeminiRequestReadConfig( + template_config=types.GeminiTemplateConfig( + gemini_example=types.GeminiExample( + contents=[ + { + "role": "user", + "parts": [{"text": "What is the capital of {name}?"}], + } + ], + ), + ), + ), + ) + assert isinstance(operation, types.MultimodalDatasetOperation) + + +@pytest.mark.asyncio +async def test_assess_tuning_resources_async(client): + response = await client.aio.datasets.assess_tuning_resources( + dataset_name=DATASET, + model_name="gemini-2.5-flash-001", + template_config=types.GeminiTemplateConfig( + gemini_example=types.GeminiExample( + contents=[ + { + "role": "user", + "parts": [{"text": "What is the capital of {name}?"}], + } + ], + ), + ), + ) + assert isinstance(response, types.TuningResourceUsageAssessmentResult) diff --git a/vertexai/_genai/datasets.py b/vertexai/_genai/datasets.py index 0f3cf69594..ae5fb24f62 100644 --- a/vertexai/_genai/datasets.py +++ b/vertexai/_genai/datasets.py @@ -56,6 +56,58 @@ def _AssembleDatasetParameters_to_vertex( return to_object +def _AssessDatasetParameters_to_vertex( + from_object: Union[dict[str, Any], object], + parent_object: Optional[dict[str, Any]] = None, +) -> dict[str, Any]: + to_object: dict[str, Any] = {} + if getv(from_object, ["config"]) is not None: + setv(to_object, ["config"], getv(from_object, ["config"])) + + if getv(from_object, ["name"]) is not None: + setv(to_object, ["_url", "name"], getv(from_object, ["name"])) + + if getv(from_object, ["gemini_request_read_config"]) is not None: + setv( + to_object, + ["geminiRequestReadConfig"], + getv(from_object, ["gemini_request_read_config"]), + ) + + if getv(from_object, ["tuning_resource_usage_assessment_config"]) is not None: + setv( + to_object, + ["tuningResourceUsageAssessmentConfig"], + getv(from_object, ["tuning_resource_usage_assessment_config"]), + ) + + if getv(from_object, ["tuning_validation_assessment_config"]) is not None: + setv( + to_object, + ["tuningValidationAssessmentConfig"], + getv(from_object, ["tuning_validation_assessment_config"]), + ) + + if ( + getv(from_object, ["batch_prediction_resource_usage_assessment_config"]) + is not None + ): + setv( + to_object, + ["batchPredictionResourceUsageAssessmentConfig"], + getv(from_object, ["batch_prediction_resource_usage_assessment_config"]), + ) + + if getv(from_object, ["batch_prediction_validation_assessment_config"]) is not None: + setv( + to_object, + ["batchPredictionValidationAssessmentConfig"], + getv(from_object, ["batch_prediction_validation_assessment_config"]), + ) + + return to_object + + def _CreateMultimodalDatasetParameters_to_vertex( from_object: Union[dict[str, Any], object], parent_object: Optional[dict[str, Any]] = None, @@ -252,6 +304,79 @@ def _assemble_multimodal_dataset( self._api_client._verify_response(return_value) return return_value + def _assess_multimodal_dataset( + self, + *, + config: Optional[types.AssessDatasetConfigOrDict] = None, + name: str, + gemini_request_read_config: Optional[ + types.GeminiRequestReadConfigOrDict + ] = None, + tuning_resource_usage_assessment_config: Optional[ + types.TuningResourceUsageAssessmentConfigOrDict + ] = None, + tuning_validation_assessment_config: Optional[ + types.TuningValidationAssessmentConfigOrDict + ] = None, + batch_prediction_resource_usage_assessment_config: Optional[ + types.BatchPredictionResourceUsageAssessmentConfigOrDict + ] = None, + batch_prediction_validation_assessment_config: Optional[ + types.BatchPredictionValidationAssessmentConfigOrDict + ] = None, + ) -> types.MultimodalDatasetOperation: + """ + Assesses a multimodal dataset resource. + """ + + parameter_model = types._AssessDatasetParameters( + config=config, + name=name, + gemini_request_read_config=gemini_request_read_config, + tuning_resource_usage_assessment_config=tuning_resource_usage_assessment_config, + tuning_validation_assessment_config=tuning_validation_assessment_config, + batch_prediction_resource_usage_assessment_config=batch_prediction_resource_usage_assessment_config, + batch_prediction_validation_assessment_config=batch_prediction_validation_assessment_config, + ) + + request_url_dict: Optional[dict[str, str]] + if not self._api_client.vertexai: + raise ValueError("This method is only supported in the Vertex AI client.") + else: + request_dict = _AssessDatasetParameters_to_vertex(parameter_model) + request_url_dict = request_dict.get("_url") + if request_url_dict: + path = "datasets/{name}:assess".format_map(request_url_dict) + else: + path = "datasets/{name}:assess" + + query_params = request_dict.get("_query") + if query_params: + path = f"{path}?{urlencode(query_params)}" + # TODO: remove the hack that pops config. + request_dict.pop("config", None) + + http_options: Optional[types.HttpOptions] = None + if ( + parameter_model.config is not None + and parameter_model.config.http_options is not None + ): + http_options = parameter_model.config.http_options + + request_dict = _common.convert_to_dict(request_dict) + request_dict = _common.encode_unserializable_types(request_dict) + + response = self._api_client.request("post", path, request_dict, http_options) + + response_dict = {} if not response.body else json.loads(response.body) + + return_value = types.MultimodalDatasetOperation._from_response( + response=response_dict, kwargs=parameter_model.model_dump() + ) + + self._api_client._verify_response(return_value) + return return_value + def _create_multimodal_dataset( self, *, @@ -875,6 +1000,60 @@ def assemble( ) return response["bigqueryDestination"] + def assess_tuning_resources( + self, + *, + dataset_name: str, + model_name: str, + template_config: Optional[types.GeminiTemplateConfigOrDict] = None, + config: Optional[types.AssessDatasetConfigOrDict] = None, + ) -> types.TuningResourceUsageAssessmentResult: + """Assess the tuning resources required for a given model. + + Args: + dataset_name: + Required. The name of the dataset to assess the tuning resources + for. + model_name: + Required. The name of the model to assess the tuning resources + for. + template_config: + Optional. The template config used to assemble the dataset + before assessing the tuning resources. If not provided, the + template config attached to the dataset will be used. Required + if no template config is attached to the dataset. + config: + Optional. A configuration for assessing the tuning resources. If not + provided, the default configuration will be used. + + Returns: + A types.TuningResourceUsageAssessmentResult object representing the + tuning resource usage assessment result. + """ + if isinstance(config, dict): + config = types.AssessDatasetConfig(**config) + elif not config: + config = types.AssessDatasetConfig() + + operation = self._assess_multimodal_dataset( + name=dataset_name, + tuning_resource_usage_assessment_config=types.TuningResourceUsageAssessmentConfig( + model_name=model_name + ), + gemini_request_read_config=types.GeminiRequestReadConfig( + template_config=template_config, + ), + config=config, + ) + response = self._wait_for_operation( + operation=operation, + timeout_seconds=config.timeout, + ) + return _datasets_utils.create_from_response( + types.TuningResourceUsageAssessmentResult, + response["tuningResourceUsageAssessmentResult"], + ) + class AsyncDatasets(_api_module.BaseModule): @@ -937,6 +1116,81 @@ async def _assemble_multimodal_dataset( self._api_client._verify_response(return_value) return return_value + async def _assess_multimodal_dataset( + self, + *, + config: Optional[types.AssessDatasetConfigOrDict] = None, + name: str, + gemini_request_read_config: Optional[ + types.GeminiRequestReadConfigOrDict + ] = None, + tuning_resource_usage_assessment_config: Optional[ + types.TuningResourceUsageAssessmentConfigOrDict + ] = None, + tuning_validation_assessment_config: Optional[ + types.TuningValidationAssessmentConfigOrDict + ] = None, + batch_prediction_resource_usage_assessment_config: Optional[ + types.BatchPredictionResourceUsageAssessmentConfigOrDict + ] = None, + batch_prediction_validation_assessment_config: Optional[ + types.BatchPredictionValidationAssessmentConfigOrDict + ] = None, + ) -> types.MultimodalDatasetOperation: + """ + Assesses a multimodal dataset resource. + """ + + parameter_model = types._AssessDatasetParameters( + config=config, + name=name, + gemini_request_read_config=gemini_request_read_config, + tuning_resource_usage_assessment_config=tuning_resource_usage_assessment_config, + tuning_validation_assessment_config=tuning_validation_assessment_config, + batch_prediction_resource_usage_assessment_config=batch_prediction_resource_usage_assessment_config, + batch_prediction_validation_assessment_config=batch_prediction_validation_assessment_config, + ) + + request_url_dict: Optional[dict[str, str]] + if not self._api_client.vertexai: + raise ValueError("This method is only supported in the Vertex AI client.") + else: + request_dict = _AssessDatasetParameters_to_vertex(parameter_model) + request_url_dict = request_dict.get("_url") + if request_url_dict: + path = "datasets/{name}:assess".format_map(request_url_dict) + else: + path = "datasets/{name}:assess" + + query_params = request_dict.get("_query") + if query_params: + path = f"{path}?{urlencode(query_params)}" + # TODO: remove the hack that pops config. + request_dict.pop("config", None) + + http_options: Optional[types.HttpOptions] = None + if ( + parameter_model.config is not None + and parameter_model.config.http_options is not None + ): + http_options = parameter_model.config.http_options + + request_dict = _common.convert_to_dict(request_dict) + request_dict = _common.encode_unserializable_types(request_dict) + + response = await self._api_client.async_request( + "post", path, request_dict, http_options + ) + + response_dict = {} if not response.body else json.loads(response.body) + + return_value = types.MultimodalDatasetOperation._from_response( + response=response_dict, kwargs=parameter_model.model_dump() + ) + + self._api_client._verify_response(return_value) + return return_value + async def _create_multimodal_dataset( self, *, @@ -1567,3 +1821,57 @@ async def assemble( timeout_seconds=config.timeout, ) return response["bigqueryDestination"] + + async def assess_tuning_resources( + self, + *, + dataset_name: str, + model_name: str, + template_config: Optional[types.GeminiTemplateConfigOrDict] = None, + config: Optional[types.AssessDatasetConfigOrDict] = None, + ) -> types.TuningResourceUsageAssessmentResult: + """Assess the tuning resources required for a given model. + + Args: + dataset_name: + Required. The name of the dataset to assess the tuning resources + for. + model_name: + Required. The name of the model to assess the tuning resources + for. + template_config: + Optional. The template config used to assemble the dataset + before assessing the tuning resources. If not provided, the + template config attached to the dataset will be used. Required + if no template config is attached to the dataset. + config: + Optional. A configuration for assessing the tuning resources. If not + provided, the default configuration will be used. + + Returns: + A types.TuningResourceUsageAssessmentResult object representing the + tuning resource usage assessment result. + """ + if isinstance(config, dict): + config = types.AssessDatasetConfig(**config) + elif not config: + config = types.AssessDatasetConfig() + + operation = await self._assess_multimodal_dataset( + name=dataset_name, + tuning_resource_usage_assessment_config=types.TuningResourceUsageAssessmentConfig( + model_name=model_name + ), + gemini_request_read_config=types.GeminiRequestReadConfig( + template_config=template_config, + ), + config=config, + ) + response = await self._wait_for_operation( + operation=operation, + timeout_seconds=config.timeout, + ) + return _datasets_utils.create_from_response( + types.TuningResourceUsageAssessmentResult, + response["tuningResourceUsageAssessmentResult"], + ) diff --git a/vertexai/_genai/types/__init__.py b/vertexai/_genai/types/__init__.py index f8dafa2a0f..32c5be73a2 100644 --- a/vertexai/_genai/types/__init__.py +++ b/vertexai/_genai/types/__init__.py @@ -23,6 +23,7 @@ from . import evals from .common import _AppendAgentEngineSessionEventRequestParameters from .common import _AssembleDatasetParameters +from .common import _AssessDatasetParameters from .common import _CreateAgentEngineMemoryRequestParameters from .common import _CreateAgentEngineRequestParameters from .common import _CreateAgentEngineSandboxRequestParameters @@ -130,6 +131,18 @@ from .common import AssembleDatasetConfigOrDict from .common import AssembleDatasetDict from .common import AssembleDatasetOrDict +from .common import AssessDatasetConfig +from .common import AssessDatasetConfigDict +from .common import AssessDatasetConfigOrDict +from .common import BatchPredictionResourceUsageAssessmentConfig +from .common import BatchPredictionResourceUsageAssessmentConfigDict +from .common import BatchPredictionResourceUsageAssessmentConfigOrDict +from .common import BatchPredictionResourceUsageAssessmentResult +from .common import BatchPredictionResourceUsageAssessmentResultDict +from .common import BatchPredictionResourceUsageAssessmentResultOrDict +from .common import BatchPredictionValidationAssessmentConfig +from .common import BatchPredictionValidationAssessmentConfigDict +from .common import BatchPredictionValidationAssessmentConfigOrDict from .common import BigQueryRequestSet from .common import BigQueryRequestSetDict from .common import BigQueryRequestSetOrDict @@ -955,6 +968,18 @@ from .common import ToolParameterKVMatchSpec from .common import ToolParameterKVMatchSpecDict from .common import ToolParameterKVMatchSpecOrDict +from .common import TuningResourceUsageAssessmentConfig +from .common import TuningResourceUsageAssessmentConfigDict +from .common import TuningResourceUsageAssessmentConfigOrDict +from .common import TuningResourceUsageAssessmentResult +from .common import TuningResourceUsageAssessmentResultDict +from .common import TuningResourceUsageAssessmentResultOrDict +from .common import TuningValidationAssessmentConfig +from .common import TuningValidationAssessmentConfigDict +from .common import TuningValidationAssessmentConfigOrDict +from .common import TuningValidationAssessmentResult +from .common import TuningValidationAssessmentResultDict +from .common import TuningValidationAssessmentResultOrDict from .common import Type from .common import UnifiedMetric from .common import UnifiedMetricDict @@ -1618,6 +1643,21 @@ "MultimodalDatasetOperation", "MultimodalDatasetOperationDict", "MultimodalDatasetOperationOrDict", + "AssessDatasetConfig", + "AssessDatasetConfigDict", + "AssessDatasetConfigOrDict", + "TuningResourceUsageAssessmentConfig", + "TuningResourceUsageAssessmentConfigDict", + "TuningResourceUsageAssessmentConfigOrDict", + "TuningValidationAssessmentConfig", + "TuningValidationAssessmentConfigDict", + "TuningValidationAssessmentConfigOrDict", + "BatchPredictionResourceUsageAssessmentConfig", + "BatchPredictionResourceUsageAssessmentConfigDict", + "BatchPredictionResourceUsageAssessmentConfigOrDict", + "BatchPredictionValidationAssessmentConfig", + "BatchPredictionValidationAssessmentConfigDict", + "BatchPredictionValidationAssessmentConfigOrDict", "CreateMultimodalDatasetConfig", "CreateMultimodalDatasetConfigDict", "CreateMultimodalDatasetConfigOrDict", @@ -1804,6 +1844,15 @@ "AssembleDataset", "AssembleDatasetDict", "AssembleDatasetOrDict", + "BatchPredictionResourceUsageAssessmentResult", + "BatchPredictionResourceUsageAssessmentResultDict", + "BatchPredictionResourceUsageAssessmentResultOrDict", + "TuningResourceUsageAssessmentResult", + "TuningResourceUsageAssessmentResultDict", + "TuningResourceUsageAssessmentResultOrDict", + "TuningValidationAssessmentResult", + "TuningValidationAssessmentResultDict", + "TuningValidationAssessmentResultOrDict", "Prompt", "PromptDict", "PromptOrDict", @@ -1908,6 +1957,7 @@ "_AppendAgentEngineSessionEventRequestParameters", "_ListAgentEngineSessionEventsRequestParameters", "_AssembleDatasetParameters", + "_AssessDatasetParameters", "_CreateMultimodalDatasetParameters", "_DeleteMultimodalDatasetRequestParameters", "_GetMultimodalDatasetParameters", diff --git a/vertexai/_genai/types/common.py b/vertexai/_genai/types/common.py index da5e9d47ff..1fefe3652c 100644 --- a/vertexai/_genai/types/common.py +++ b/vertexai/_genai/types/common.py @@ -9929,6 +9929,169 @@ class MultimodalDatasetOperationDict(TypedDict, total=False): ] +class AssessDatasetConfig(_common.BaseModel): + """Config for assessing a multimodal dataset resource.""" + + http_options: Optional[genai_types.HttpOptions] = Field( + default=None, description="""Used to override HTTP request options.""" + ) + timeout: Optional[int] = Field( + default=90, + description="""The timeout for the assess dataset request in seconds. If not set, + the default timeout is 90 seconds.""", + ) + + +class AssessDatasetConfigDict(TypedDict, total=False): + """Config for assessing a multimodal dataset resource.""" + + http_options: Optional[genai_types.HttpOptionsDict] + """Used to override HTTP request options.""" + + timeout: Optional[int] + """The timeout for the assess dataset request in seconds. If not set, + the default timeout is 90 seconds.""" + + +AssessDatasetConfigOrDict = Union[AssessDatasetConfig, AssessDatasetConfigDict] + + +class TuningResourceUsageAssessmentConfig(_common.BaseModel): + """Config for tuning resource usage assessment.""" + + model_name: Optional[str] = Field(default=None, description="""""") + + +class TuningResourceUsageAssessmentConfigDict(TypedDict, total=False): + """Config for tuning resource usage assessment.""" + + model_name: Optional[str] + """""" + + +TuningResourceUsageAssessmentConfigOrDict = Union[ + TuningResourceUsageAssessmentConfig, TuningResourceUsageAssessmentConfigDict +] + + +class TuningValidationAssessmentConfig(_common.BaseModel): + """Config for tuning validation assessment.""" + + model_name: Optional[str] = Field(default=None, description="""""") + dataset_usage: Optional[str] = Field(default=None, description="""""") + + +class TuningValidationAssessmentConfigDict(TypedDict, total=False): + """Config for tuning validation assessment.""" + + model_name: Optional[str] + """""" + + dataset_usage: Optional[str] + """""" + + +TuningValidationAssessmentConfigOrDict = Union[ + TuningValidationAssessmentConfig, TuningValidationAssessmentConfigDict +] + + +class BatchPredictionResourceUsageAssessmentConfig(_common.BaseModel): + """Config for batch prediction resource usage assessment.""" + + model_name: Optional[str] = Field(default=None, description="""""") + + +class BatchPredictionResourceUsageAssessmentConfigDict(TypedDict, total=False): + """Config for batch prediction resource usage assessment.""" + + model_name: Optional[str] + """""" + + +BatchPredictionResourceUsageAssessmentConfigOrDict = Union[ + BatchPredictionResourceUsageAssessmentConfig, + BatchPredictionResourceUsageAssessmentConfigDict, +] + + +class BatchPredictionValidationAssessmentConfig(_common.BaseModel): + """Config for batch prediction validation assessment.""" + + model_name: Optional[str] = Field(default=None, description="""""") + + +class BatchPredictionValidationAssessmentConfigDict(TypedDict, total=False): + """Config for batch prediction validation assessment.""" + + model_name: Optional[str] + """""" + + +BatchPredictionValidationAssessmentConfigOrDict = Union[ + BatchPredictionValidationAssessmentConfig, + BatchPredictionValidationAssessmentConfigDict, +] + + +class _AssessDatasetParameters(_common.BaseModel): + """Parameters for assessing a multimodal dataset resource.""" + + config: Optional[AssessDatasetConfig] = Field(default=None, description="""""") + name: Optional[str] = Field(default=None, description="""""") + gemini_request_read_config: Optional[GeminiRequestReadConfig] = Field( + default=None, description="""""" + ) + tuning_resource_usage_assessment_config: Optional[ + TuningResourceUsageAssessmentConfig + ] = Field(default=None, description="""""") + tuning_validation_assessment_config: Optional[TuningValidationAssessmentConfig] = ( + Field(default=None, description="""""") + ) + batch_prediction_resource_usage_assessment_config: Optional[ + BatchPredictionResourceUsageAssessmentConfig + ] = Field(default=None, description="""""") + batch_prediction_validation_assessment_config: Optional[ + BatchPredictionValidationAssessmentConfig + ] = Field(default=None, description="""""") + + +class _AssessDatasetParametersDict(TypedDict, total=False): + """Parameters for assessing a multimodal dataset resource.""" + + config: Optional[AssessDatasetConfigDict] + """""" + + name: Optional[str] + """""" + + gemini_request_read_config: Optional[GeminiRequestReadConfigDict] + """""" + + tuning_resource_usage_assessment_config: Optional[ + TuningResourceUsageAssessmentConfigDict + ] + """""" + + tuning_validation_assessment_config: Optional[TuningValidationAssessmentConfigDict] + """""" + + batch_prediction_resource_usage_assessment_config: Optional[ + BatchPredictionResourceUsageAssessmentConfigDict + ] + """""" + + batch_prediction_validation_assessment_config: Optional[ + BatchPredictionValidationAssessmentConfigDict + ] + """""" + + +_AssessDatasetParametersOrDict = Union[ + _AssessDatasetParameters, _AssessDatasetParametersDict +] + + class CreateMultimodalDatasetConfig(_common.BaseModel): """Config for creating a dataset resource to store multimodal dataset.""" @@ -13485,6 +13648,80 @@ class AssembleDatasetDict(TypedDict, total=False): AssembleDatasetOrDict = Union[AssembleDataset, AssembleDatasetDict] +class BatchPredictionResourceUsageAssessmentResult(_common.BaseModel): + """Result of batch prediction resource usage assessment.""" + + token_count: Optional[int] = Field( + default=None, description="""Number of tokens in the dataset.""" + ) + audio_token_count: Optional[int] = Field( + default=None, description="""Number of audio tokens in the dataset.""" + ) + + +class BatchPredictionResourceUsageAssessmentResultDict(TypedDict, total=False): + """Result of batch prediction resource usage assessment.""" + + token_count: Optional[int] + """Number of tokens in the dataset.""" + + audio_token_count: Optional[int] + """Number of audio tokens in the dataset.""" + + +BatchPredictionResourceUsageAssessmentResultOrDict = Union[ + BatchPredictionResourceUsageAssessmentResult, + BatchPredictionResourceUsageAssessmentResultDict, +] + + +class TuningResourceUsageAssessmentResult(_common.BaseModel): + """Result of tuning resource usage assessment.""" + + token_count: Optional[int] = Field( + default=None, description="""The number of tokens in the dataset.""" + ) + billable_character_count: Optional[int] = Field( + default=None, + description="""The number of billable characters in the dataset.""", + ) + + +class TuningResourceUsageAssessmentResultDict(TypedDict, total=False): + """Result of tuning resource usage assessment.""" + + token_count: Optional[int] + """The number of tokens in the dataset.""" + + billable_character_count: Optional[int] + """The number of billable characters in the dataset.""" + + +TuningResourceUsageAssessmentResultOrDict = Union[ + TuningResourceUsageAssessmentResult, TuningResourceUsageAssessmentResultDict +] + + +class TuningValidationAssessmentResult(_common.BaseModel): + """The result of a tuning validation assessment.""" + + errors: Optional[list[str]] = Field( + default=None, description="""The list of errors found in the dataset.""" + ) + + +class TuningValidationAssessmentResultDict(TypedDict, total=False): + """The result of a tuning validation assessment.""" + + errors: Optional[list[str]] + """The list of errors found in the dataset.""" + + +TuningValidationAssessmentResultOrDict = Union[ + TuningValidationAssessmentResult, TuningValidationAssessmentResultDict +] + + class Prompt(_common.BaseModel): """Represents a prompt."""