google-genai 1.0.0rc0__py3-none-any.whl → 1.1.0__py3-none-any.whl

google/genai/tunings.py

@@ -655,42 +655,50 @@ def _ListTuningJobsResponse_from_vertex(
   return to_object
 
 
-def _TuningJobOrOperation_from_mldev(
+def _Operation_from_mldev(
     api_client: ApiClient,
     from_object: Union[dict, object],
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
-  if getv(from_object, ['_self']) is not None:
-    setv(
-        to_object,
-        ['tuning_job'],
-        _TuningJob_from_mldev(
-            api_client,
-            t.t_resolve_operation(api_client, getv(from_object, ['_self'])),
-            to_object,
-        ),
-    )
+  if getv(from_object, ['name']) is not None:
+    setv(to_object, ['name'], getv(from_object, ['name']))
+
+  if getv(from_object, ['metadata']) is not None:
+    setv(to_object, ['metadata'], getv(from_object, ['metadata']))
+
+  if getv(from_object, ['done']) is not None:
+    setv(to_object, ['done'], getv(from_object, ['done']))
+
+  if getv(from_object, ['error']) is not None:
+    setv(to_object, ['error'], getv(from_object, ['error']))
+
+  if getv(from_object, ['response']) is not None:
+    setv(to_object, ['response'], getv(from_object, ['response']))
 
   return to_object
 
 
-def _TuningJobOrOperation_from_vertex(
+def _Operation_from_vertex(
     api_client: ApiClient,
     from_object: Union[dict, object],
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
-  if getv(from_object, ['_self']) is not None:
-    setv(
-        to_object,
-        ['tuning_job'],
-        _TuningJob_from_vertex(
-            api_client,
-            t.t_resolve_operation(api_client, getv(from_object, ['_self'])),
-            to_object,
-        ),
-    )
+  if getv(from_object, ['name']) is not None:
+    setv(to_object, ['name'], getv(from_object, ['name']))
+
+  if getv(from_object, ['metadata']) is not None:
+    setv(to_object, ['metadata'], getv(from_object, ['metadata']))
+
+  if getv(from_object, ['done']) is not None:
+    setv(to_object, ['done'], getv(from_object, ['done']))
+
+  if getv(from_object, ['error']) is not None:
+    setv(to_object, ['error'], getv(from_object, ['error']))
+
+  if getv(from_object, ['response']) is not None:
+    setv(to_object, ['response'], getv(from_object, ['response']))
 
   return to_object
 
@@ -823,7 +831,7 @@ class Tunings(_api_module.BaseModule):
       base_model: str,
       training_dataset: types.TuningDatasetOrDict,
       config: Optional[types.CreateTuningJobConfigOrDict] = None,
-  ) -> types.TuningJobOrOperation:
+  ) -> types.TuningJob:
     """Creates a supervised fine-tuning job.
 
     Args:
@@ -841,16 +849,76 @@ class Tunings(_api_module.BaseModule):
         config=config,
     )
 
-    if self._api_client.vertexai:
+    if not self._api_client.vertexai:
+      raise ValueError('This method is only supported in the Vertex AI client.')
+    else:
       request_dict = _CreateTuningJobParameters_to_vertex(
           self._api_client, parameter_model
       )
       path = 'tuningJobs'.format_map(request_dict.get('_url'))
+
+    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 = None
+    if isinstance(config, dict):
+      http_options = config.get('http_options', None)
+    elif hasattr(config, 'http_options'):
+      http_options = config.http_options
+
+    request_dict = _common.convert_to_dict(request_dict)
+    request_dict = _common.encode_unserializable_types(request_dict)
+
+    response_dict = self._api_client.request(
+        'post', path, request_dict, http_options
+    )
+
+    if self._api_client.vertexai:
+      response_dict = _TuningJob_from_vertex(self._api_client, response_dict)
+    else:
+      response_dict = _TuningJob_from_mldev(self._api_client, response_dict)
+
+    return_value = types.TuningJob._from_response(
+        response=response_dict, kwargs=parameter_model
+    )
+    self._api_client._verify_response(return_value)
+    return return_value
+
+  def _tune_mldev(
+      self,
+      *,
+      base_model: str,
+      training_dataset: types.TuningDatasetOrDict,
+      config: Optional[types.CreateTuningJobConfigOrDict] = None,
+  ) -> types.Operation:
+    """Creates a supervised fine-tuning job.
+
+    Args:
+      base_model: The name of the model to tune.
+      training_dataset: The training dataset to use.
+      config: The configuration to use for the tuning job.
+
+    Returns:
+      A TuningJob operation.
+    """
+
+    parameter_model = types._CreateTuningJobParameters(
+        base_model=base_model,
+        training_dataset=training_dataset,
+        config=config,
+    )
+
+    if self._api_client.vertexai:
+      raise ValueError('This method is only supported in the default client.')
     else:
       request_dict = _CreateTuningJobParameters_to_mldev(
           self._api_client, parameter_model
       )
       path = 'tunedModels'.format_map(request_dict.get('_url'))
+
     query_params = request_dict.get('_query')
     if query_params:
       path = f'{path}?{urlencode(query_params)}'
@@ -871,17 +939,13 @@ class Tunings(_api_module.BaseModule):
     )
 
     if self._api_client.vertexai:
-      response_dict = _TuningJobOrOperation_from_vertex(
-          self._api_client, response_dict
-      )
+      response_dict = _Operation_from_vertex(self._api_client, response_dict)
     else:
-      response_dict = _TuningJobOrOperation_from_mldev(
-          self._api_client, response_dict
-      )
+      response_dict = _Operation_from_mldev(self._api_client, response_dict)
 
-    return_value = types.TuningJobOrOperation._from_response(
+    return_value = types.Operation._from_response(
         response=response_dict, kwargs=parameter_model
-    ).tuning_job
+    )
     self._api_client._verify_response(return_value)
     return return_value
 
@@ -909,21 +973,43 @@ class Tunings(_api_module.BaseModule):
       )
     return job
 
+  @_common.experimental_warning(
+      "The SDK's tuning implementation is experimental, "
+      'and may change in future versions.',
+  )
   def tune(
       self,
       *,
       base_model: str,
       training_dataset: types.TuningDatasetOrDict,
       config: Optional[types.CreateTuningJobConfigOrDict] = None,
-  ) -> types.TuningJobOrOperation:
-    result = self._tune(
-        base_model=base_model,
-        training_dataset=training_dataset,
-        config=config,
-    )
-    if result.name and self._api_client.vertexai:
-      _IpythonUtils.display_model_tuning_button(tuning_job_resource=result.name)
-    return result
+  ) -> types.TuningJob:
+    if self._api_client.vertexai:
+      tuning_job = self._tune(
+          base_model=base_model,
+          training_dataset=training_dataset,
+          config=config,
+      )
+    else:
+      operation = self._tune_mldev(
+          base_model=base_model,
+          training_dataset=training_dataset,
+          config=config,
+      )
+      operation_dict = operation.to_json_dict()
+      try:
+        tuned_model_name = operation_dict['metadata']['tunedModel']
+      except KeyError:
+        tuned_model_name = operation_dict['name'].partition('/operations/')[0]
+      tuning_job = types.TuningJob(
+          name=tuned_model_name,
+          state=types.JobState.JOB_STATE_QUEUED,
+      )
+    if tuning_job.name and self._api_client.vertexai:
+      _IpythonUtils.display_model_tuning_button(
+          tuning_job_resource=tuning_job.name
+      )
+    return tuning_job
 
 
 class AsyncTunings(_api_module.BaseModule):
@@ -1054,7 +1140,7 @@ class AsyncTunings(_api_module.BaseModule):
       base_model: str,
       training_dataset: types.TuningDatasetOrDict,
       config: Optional[types.CreateTuningJobConfigOrDict] = None,
-  ) -> types.TuningJobOrOperation:
+  ) -> types.TuningJob:
     """Creates a supervised fine-tuning job.
 
     Args:
@@ -1072,16 +1158,76 @@ class AsyncTunings(_api_module.BaseModule):
         config=config,
     )
 
-    if self._api_client.vertexai:
+    if not self._api_client.vertexai:
+      raise ValueError('This method is only supported in the Vertex AI client.')
+    else:
       request_dict = _CreateTuningJobParameters_to_vertex(
           self._api_client, parameter_model
       )
       path = 'tuningJobs'.format_map(request_dict.get('_url'))
+
+    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 = None
+    if isinstance(config, dict):
+      http_options = config.get('http_options', None)
+    elif hasattr(config, 'http_options'):
+      http_options = config.http_options
+
+    request_dict = _common.convert_to_dict(request_dict)
+    request_dict = _common.encode_unserializable_types(request_dict)
+
+    response_dict = await self._api_client.async_request(
+        'post', path, request_dict, http_options
+    )
+
+    if self._api_client.vertexai:
+      response_dict = _TuningJob_from_vertex(self._api_client, response_dict)
+    else:
+      response_dict = _TuningJob_from_mldev(self._api_client, response_dict)
+
+    return_value = types.TuningJob._from_response(
+        response=response_dict, kwargs=parameter_model
+    )
+    self._api_client._verify_response(return_value)
+    return return_value
+
+  async def _tune_mldev(
+      self,
+      *,
+      base_model: str,
+      training_dataset: types.TuningDatasetOrDict,
+      config: Optional[types.CreateTuningJobConfigOrDict] = None,
+  ) -> types.Operation:
+    """Creates a supervised fine-tuning job.
+
+    Args:
+      base_model: The name of the model to tune.
+      training_dataset: The training dataset to use.
+      config: The configuration to use for the tuning job.
+
+    Returns:
+      A TuningJob operation.
+    """
+
+    parameter_model = types._CreateTuningJobParameters(
+        base_model=base_model,
+        training_dataset=training_dataset,
+        config=config,
+    )
+
+    if self._api_client.vertexai:
+      raise ValueError('This method is only supported in the default client.')
     else:
       request_dict = _CreateTuningJobParameters_to_mldev(
           self._api_client, parameter_model
       )
       path = 'tunedModels'.format_map(request_dict.get('_url'))
+
     query_params = request_dict.get('_query')
     if query_params:
       path = f'{path}?{urlencode(query_params)}'
@@ -1102,17 +1248,13 @@ class AsyncTunings(_api_module.BaseModule):
     )
 
     if self._api_client.vertexai:
-      response_dict = _TuningJobOrOperation_from_vertex(
-          self._api_client, response_dict
-      )
+      response_dict = _Operation_from_vertex(self._api_client, response_dict)
     else:
-      response_dict = _TuningJobOrOperation_from_mldev(
-          self._api_client, response_dict
-      )
+      response_dict = _Operation_from_mldev(self._api_client, response_dict)
 
-    return_value = types.TuningJobOrOperation._from_response(
+    return_value = types.Operation._from_response(
         response=response_dict, kwargs=parameter_model
-    ).tuning_job
+    )
     self._api_client._verify_response(return_value)
     return return_value
 
@@ -1140,21 +1282,43 @@ class AsyncTunings(_api_module.BaseModule):
       )
     return job
 
+  @_common.experimental_warning(
+      "The SDK's tuning implementation is experimental, "
+      'and may change in future versions.'
+  )
   async def tune(
       self,
       *,
       base_model: str,
       training_dataset: types.TuningDatasetOrDict,
       config: Optional[types.CreateTuningJobConfigOrDict] = None,
-  ) -> types.TuningJobOrOperation:
-    result = await self._tune(
-        base_model=base_model,
-        training_dataset=training_dataset,
-        config=config,
-    )
-    if result.name and self._api_client.vertexai:
-      _IpythonUtils.display_model_tuning_button(tuning_job_resource=result.name)
-    return result
+  ) -> types.TuningJob:
+    if self._api_client.vertexai:
+      tuning_job = await self._tune(
+          base_model=base_model,
+          training_dataset=training_dataset,
+          config=config,
+      )
+    else:
+      operation = await self._tune_mldev(
+          base_model=base_model,
+          training_dataset=training_dataset,
+          config=config,
+      )
+      operation_dict = operation.to_json_dict()
+      try:
+        tuned_model_name = operation_dict['metadata']['tunedModel']
+      except KeyError:
+        tuned_model_name = operation_dict['name'].partition('/operations/')[0]
+      tuning_job = types.TuningJob(
+          name=tuned_model_name,
+          state=types.JobState.JOB_STATE_QUEUED,
+      )
+    if tuning_job.name and self._api_client.vertexai:
+      _IpythonUtils.display_model_tuning_button(
+          tuning_job_resource=tuning_job.name
+      )
+    return tuning_job
 
 
 class _IpythonUtils:

google/genai/types.py

@@ -723,10 +723,6 @@ class HttpOptions(_common.BaseModel):
   timeout: Optional[int] = Field(
       default=None, description="""Timeout for the request in milliseconds."""
   )
-  deprecated_response_payload: Optional[dict[str, Any]] = Field(
-      default=None,
-      description="""This field is deprecated. If set, the response payload will be returned int the supplied dict.""",
-  )
 
 
 class HttpOptionsDict(TypedDict, total=False):
@@ -744,9 +740,6 @@ class HttpOptionsDict(TypedDict, total=False):
   timeout: Optional[int]
   """Timeout for the request in milliseconds."""
 
-  deprecated_response_payload: Optional[dict[str, Any]]
-  """This field is deprecated. If set, the response payload will be returned int the supplied dict."""
-
 
 HttpOptionsOrDict = Union[HttpOptions, HttpOptionsDict]
 
@@ -978,13 +971,24 @@ class FunctionDeclaration(_common.BaseModel):
   )
 
   @classmethod
-  def from_callable(
+  def from_callable_with_api_option(
       cls,
       *,
-      client,
       callable: Callable,
+      api_option: Literal['VERTEX_AI', 'GEMINI_API'] = 'GEMINI_API',
   ) -> 'FunctionDeclaration':
-    """Converts a Callable to a FunctionDeclaration based on the client."""
+    """Converts a Callable to a FunctionDeclaration based on the API option.
+
+    Supported API option is 'VERTEX_AI' or 'GEMINI_API'. If api_option is unset,
+    it will default to 'GEMINI_API'. If unsupported api_option is provided, it
+    will raise ValueError.
+    """
+    supported_api_options = ['VERTEX_AI', 'GEMINI_API']
+    if api_option not in supported_api_options:
+      raise ValueError(
+          f'Unsupported api_option value: {api_option}. Supported api_option'
+          f' value is one of: {supported_api_options}.'
+      )
     from . import _automatic_function_calling_util
 
     parameters_properties = {}
@@ -995,7 +999,7 @@ class FunctionDeclaration(_common.BaseModel):
           inspect.Parameter.POSITIONAL_ONLY,
       ):
         schema = _automatic_function_calling_util._parse_schema_from_parameter(
-            client, param, callable.__name__
+            api_option, param, callable.__name__
         )
         parameters_properties[name] = schema
     declaration = FunctionDeclaration(
@@ -1007,13 +1011,13 @@ class FunctionDeclaration(_common.BaseModel):
           type='OBJECT',
           properties=parameters_properties,
       )
-      if client.vertexai:
+      if api_option == 'VERTEX_AI':
         declaration.parameters.required = (
             _automatic_function_calling_util._get_required_fields(
                 declaration.parameters
             )
         )
-    if not client.vertexai:
+    if api_option == 'GEMINI_API':
       return declaration
 
     return_annotation = inspect.signature(callable).return_annotation
@@ -1022,7 +1026,7 @@ class FunctionDeclaration(_common.BaseModel):
 
     declaration.response = (
         _automatic_function_calling_util._parse_schema_from_parameter(
-            client,
+            api_option,
             inspect.Parameter(
                 'return_value',
                 inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -1033,6 +1037,23 @@ class FunctionDeclaration(_common.BaseModel):
     )
     return declaration
 
+  @classmethod
+  def from_callable(
+      cls,
+      *,
+      client,
+      callable: Callable,
+  ) -> 'FunctionDeclaration':
+    """Converts a Callable to a FunctionDeclaration based on the client."""
+    if client.vertexai:
+      return cls.from_callable_with_api_option(
+          callable=callable, api_option='VERTEX_AI'
+      )
+    else:
+      return cls.from_callable_with_api_option(
+          callable=callable, api_option='GEMINI_API'
+      )
+
 
 class FunctionDeclarationDict(TypedDict, total=False):
   """Defines a function that the model can generate JSON inputs for.
@@ -1916,6 +1937,20 @@ class GenerateContentConfig(_common.BaseModel):
       """,
   )
 
+  @pydantic.field_validator('response_schema', mode='before')
+  @classmethod
+  def _convert_literal_to_enum(cls, value):
+    if typing.get_origin(value) is typing.Literal:
+      enum_vals = typing.get_args(value)
+      if not all(isinstance(arg, str) for arg in enum_vals):
+        # This doesn't stop execution, it tells pydantic to raise a ValidationError
+        # when the class is instantiated with an unsupported Literal
+        raise ValueError(f'Literal type {value} must be a list of strings.')
+      # The title 'PlaceholderLiteralEnum' is removed from the generated Schema
+      # before sending the request
+      return Enum('PlaceholderLiteralEnum', {s: s for s in enum_vals})
+    return value
+
 
 class GenerateContentConfigDict(TypedDict, total=False):
   """Optional model configuration parameters.
@@ -2822,7 +2857,7 @@ class GenerateContentResponse(_common.BaseModel):
     text = ''
     any_text_part_text = False
     for part in self.candidates[0].content.parts:
-      for field_name, field_value in part.dict(
+      for field_name, field_value in part.model_dump(
           exclude={'text', 'thought'}
       ).items():
         if field_value is not None:
@@ -2890,6 +2925,11 @@ class GenerateContentResponse(_common.BaseModel):
       enum_value = result.text.replace('"', '')
       try:
         result.parsed = response_schema(enum_value)
+        if (
+            hasattr(response_schema, '__name__')
+            and response_schema.__name__ == 'PlaceholderLiteralEnum'
+        ):
+          result.parsed = str(response_schema(enum_value).name)
       except ValueError:
         pass
     elif isinstance(response_schema, GenericAlias) or isinstance(
@@ -5961,22 +6001,51 @@ _CreateTuningJobParametersOrDict = Union[
 ]
 
 
-class TuningJobOrOperation(_common.BaseModel):
-  """A tuning job or an long-running-operation that resolves to a tuning job."""
+class Operation(_common.BaseModel):
+  """A long-running operation."""
 
-  tuning_job: Optional[TuningJob] = Field(default=None, description="""""")
+  name: Optional[str] = Field(
+      default=None,
+      description="""The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.""",
+  )
+  metadata: Optional[dict[str, Any]] = Field(
+      default=None,
+      description="""Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any.""",
+  )
+  done: Optional[bool] = Field(
+      default=None,
+      description="""If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.""",
+  )
+  error: Optional[dict[str, Any]] = Field(
+      default=None,
+      description="""The error result of the operation in case of failure or cancellation.""",
+  )
+  response: Optional[dict[str, Any]] = Field(
+      default=None,
+      description="""The normal response of the operation in case of success.""",
+  )
 
 
-class TuningJobOrOperationDict(TypedDict, total=False):
-  """A tuning job or an long-running-operation that resolves to a tuning job."""
+class OperationDict(TypedDict, total=False):
+  """A long-running operation."""
 
-  tuning_job: Optional[TuningJobDict]
-  """"""
+  name: Optional[str]
+  """The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`."""
+
+  metadata: Optional[dict[str, Any]]
+  """Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any."""
 
+  done: Optional[bool]
+  """If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available."""
 
-TuningJobOrOperationOrDict = Union[
-    TuningJobOrOperation, TuningJobOrOperationDict
-]
+  error: Optional[dict[str, Any]]
+  """The error result of the operation in case of failure or cancellation."""
+
+  response: Optional[dict[str, Any]]
+  """The normal response of the operation in case of success."""
+
+
+OperationOrDict = Union[Operation, OperationDict]
 
 
 class CreateCachedContentConfig(_common.BaseModel):
@@ -6583,13 +6652,17 @@ _CreateFileParametersOrDict = Union[
 class CreateFileResponse(_common.BaseModel):
   """Response for the create file method."""
 
-  pass
+  http_headers: Optional[dict[str, str]] = Field(
+      default=None,
+      description="""Used to retain the HTTP headers in the request""",
+  )
 
 
 class CreateFileResponseDict(TypedDict, total=False):
   """Response for the create file method."""
 
-  pass
+  http_headers: Optional[dict[str, str]]
+  """Used to retain the HTTP headers in the request"""
 
 
 CreateFileResponseOrDict = Union[CreateFileResponse, CreateFileResponseDict]
@@ -7285,53 +7358,6 @@ _GetOperationParametersOrDict = Union[
 ]
 
 
-class Operation(_common.BaseModel):
-  """A long-running operation."""
-
-  name: Optional[str] = Field(
-      default=None,
-      description="""The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.""",
-  )
-  metadata: Optional[dict[str, Any]] = Field(
-      default=None,
-      description="""Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any.""",
-  )
-  done: Optional[bool] = Field(
-      default=None,
-      description="""If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.""",
-  )
-  error: Optional[dict[str, Any]] = Field(
-      default=None,
-      description="""The error result of the operation in case of failure or cancellation.""",
-  )
-  response: Optional[dict[str, Any]] = Field(
-      default=None,
-      description="""The normal response of the operation in case of success.""",
-  )
-
-
-class OperationDict(TypedDict, total=False):
-  """A long-running operation."""
-
-  name: Optional[str]
-  """The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`."""
-
-  metadata: Optional[dict[str, Any]]
-  """Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any."""
-
-  done: Optional[bool]
-  """If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available."""
-
-  error: Optional[dict[str, Any]]
-  """The error result of the operation in case of failure or cancellation."""
-
-  response: Optional[dict[str, Any]]
-  """The normal response of the operation in case of success."""
-
-
-OperationOrDict = Union[Operation, OperationDict]
-
-
 class FetchPredictOperationConfig(_common.BaseModel):
 
   http_options: Optional[HttpOptions] = Field(

google/genai/version.py

@@ -13,4 +13,4 @@
 # limitations under the License.
 #
 
-__version__ = '1.0.0rc0' # x-release-please-version
+__version__ = '1.1.0' # x-release-please-version