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

google/genai/types.py

@@ -22,9 +22,10 @@ import json
 import logging
 import sys
 import typing
-from typing import Any, Callable, GenericAlias, Literal, Optional, Type, TypedDict, Union
+from typing import Any, Callable, GenericAlias, Literal, Optional, Union
 import pydantic
 from pydantic import Field
+from typing_extensions import TypedDict
 from . import _common
 
 if sys.version_info >= (3, 10):
@@ -43,7 +44,7 @@ if typing.TYPE_CHECKING:
   PIL_Image = PIL.Image.Image
   _is_pillow_image_imported = True
 else:
-  PIL_Image: Type = Any
+  PIL_Image: typing.Type = Any
   try:
     import PIL.Image
 
@@ -723,10 +724,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 +741,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 +972,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 +1000,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 +1012,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 +1027,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 +1038,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.
@@ -1571,7 +1593,7 @@ class File(_common.BaseModel):
   )
   expiration_time: Optional[datetime.datetime] = Field(
       default=None,
-      description="""Optional. The human-readable display name for the `File`. The display name must be no more than 512 characters in length, including spaces. Example: 'Welcome Image'""",
+      description="""Output only. The timestamp of when the `File` will be deleted. Only set if the `File` is scheduled to expire.""",
   )
   update_time: Optional[datetime.datetime] = Field(
       default=None,
@@ -1622,7 +1644,7 @@ class FileDict(TypedDict, total=False):
   """Output only. The timestamp of when the `File` was created."""
 
   expiration_time: Optional[datetime.datetime]
-  """Optional. The human-readable display name for the `File`. The display name must be no more than 512 characters in length, including spaces. Example: 'Welcome Image'"""
+  """Output only. The timestamp of when the `File` will be deleted. Only set if the `File` is scheduled to expire."""
 
   update_time: Optional[datetime.datetime]
   """Output only. The timestamp of when the `File` was last updated."""
@@ -1916,6 +1938,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 +2858,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 +2926,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 +6002,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."""
+
+  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.""",
+  )
 
-  tuning_job: Optional[TuningJob] = Field(default=None, description="""""")
 
+class OperationDict(TypedDict, total=False):
+  """A long-running operation."""
 
-class TuningJobOrOperationDict(TypedDict, total=False):
-  """A tuning job or an long-running-operation that resolves to a tuning job."""
+  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}`."""
 
-  tuning_job: Optional[TuningJobDict]
-  """"""
+  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 +6653,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 +7359,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.2.0' # x-release-please-version