google-genai 0.3.0__tar.gz → 0.4.0__tar.gz

{google_genai-0.3.0/google_genai.egg-info → google_genai-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: google-genai
-Version: 0.3.0
+Version: 0.4.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0
@@ -436,10 +436,10 @@ response1 = client.models.generate_image(
     model='imagen-3.0-generate-001',
     prompt='An umbrella in the foreground, and a rainy night sky in the background',
     config=types.GenerateImageConfig(
-        negative_prompt= "human",
+        negative_prompt= 'human',
         number_of_images= 1,
         include_rai_reason= True,
-        output_mime_type= "image/jpeg"
+        output_mime_type= 'image/jpeg'
     )
 )
 response1.generated_images[0].image.show()
@@ -454,7 +454,11 @@ Upscale image is not supported in Google AI.
 response2 = client.models.upscale_image(
     model='imagen-3.0-generate-001',
     image=response1.generated_images[0].image,
-    config=types.UpscaleImageConfig(upscale_factor="x2")
+    upscale_factor='x2',
+    config=types.UpscaleImageConfig(
+        include_rai_reason= True,
+        output_mime_type= 'image/jpeg',
+    ),
 )
 response2.generated_images[0].image.show()
 ```
@@ -497,6 +501,42 @@ response3 = client.models.edit_image(
 response3.generated_images[0].image.show()
 ```
 
+## Chats
+
+Create a chat session to start a multi-turn conversations with the model.
+
+### Send Message
+
+```python
+chat = client.chats.create(model='gemini-2.0-flash-exp')
+response = chat.send_message('tell me a story')
+print(response.text)
+```
+
+### Streaming
+
+```python
+chat = client.chats.create(model='gemini-2.0-flash-exp')
+for chunk in chat.send_message_stream('tell me a story'):
+  print(chunk.text)
+```
+
+### Async
+
+```python
+chat = client.aio.chats.create(model='gemini-2.0-flash-exp')
+response = await chat.send_message('tell me a story')
+print(response.text)
+```
+
+### Async Streaming
+
+```python
+chat = client.aio.chats.create(model='gemini-2.0-flash-exp')
+async for chunk in chat.send_message_stream('tell me a story'):
+  print(chunk.text)
+```
+
 ## Files (Only Google AI)
 
 ``` python
@@ -539,19 +579,19 @@ else:
 
 cached_content = client.caches.create(
       model='gemini-1.5-pro-002',
-      contents=[
-          types.Content(
-              role='user',
-              parts=[
-                types.Part.from_uri(
-                    file_uri=file_uris[0],
-                    mime_type='application/pdf'),
-                types.Part.from_uri(
-                    file_uri=file_uris[1],
-                    mime_type='application/pdf',)])
-      ],
-      system_instruction='What is the sum of the two pdfs?',
       config=types.CreateCachedContentConfig(
+          contents=[
+              types.Content(
+                  role='user',
+                  parts=[
+                    types.Part.from_uri(
+                        file_uri=file_uris[0],
+                        mime_type='application/pdf'),
+                    types.Part.from_uri(
+                        file_uri=file_uris[1],
+                        mime_type='application/pdf',)])
+          ],
+          system_instruction='What is the sum of the two pdfs?',
           display_name='test cache',
           ttl='3600s',
       ),

{google_genai-0.3.0 → google_genai-0.4.0}/README.md

@@ -408,10 +408,10 @@ response1 = client.models.generate_image(
     model='imagen-3.0-generate-001',
     prompt='An umbrella in the foreground, and a rainy night sky in the background',
     config=types.GenerateImageConfig(
-        negative_prompt= "human",
+        negative_prompt= 'human',
         number_of_images= 1,
         include_rai_reason= True,
-        output_mime_type= "image/jpeg"
+        output_mime_type= 'image/jpeg'
     )
 )
 response1.generated_images[0].image.show()
@@ -426,7 +426,11 @@ Upscale image is not supported in Google AI.
 response2 = client.models.upscale_image(
     model='imagen-3.0-generate-001',
     image=response1.generated_images[0].image,
-    config=types.UpscaleImageConfig(upscale_factor="x2")
+    upscale_factor='x2',
+    config=types.UpscaleImageConfig(
+        include_rai_reason= True,
+        output_mime_type= 'image/jpeg',
+    ),
 )
 response2.generated_images[0].image.show()
 ```
@@ -469,6 +473,42 @@ response3 = client.models.edit_image(
 response3.generated_images[0].image.show()
 ```
 
+## Chats
+
+Create a chat session to start a multi-turn conversations with the model.
+
+### Send Message
+
+```python
+chat = client.chats.create(model='gemini-2.0-flash-exp')
+response = chat.send_message('tell me a story')
+print(response.text)
+```
+
+### Streaming
+
+```python
+chat = client.chats.create(model='gemini-2.0-flash-exp')
+for chunk in chat.send_message_stream('tell me a story'):
+  print(chunk.text)
+```
+
+### Async
+
+```python
+chat = client.aio.chats.create(model='gemini-2.0-flash-exp')
+response = await chat.send_message('tell me a story')
+print(response.text)
+```
+
+### Async Streaming
+
+```python
+chat = client.aio.chats.create(model='gemini-2.0-flash-exp')
+async for chunk in chat.send_message_stream('tell me a story'):
+  print(chunk.text)
+```
+
 ## Files (Only Google AI)
 
 ``` python
@@ -511,19 +551,19 @@ else:
 
 cached_content = client.caches.create(
       model='gemini-1.5-pro-002',
-      contents=[
-          types.Content(
-              role='user',
-              parts=[
-                types.Part.from_uri(
-                    file_uri=file_uris[0],
-                    mime_type='application/pdf'),
-                types.Part.from_uri(
-                    file_uri=file_uris[1],
-                    mime_type='application/pdf',)])
-      ],
-      system_instruction='What is the sum of the two pdfs?',
       config=types.CreateCachedContentConfig(
+          contents=[
+              types.Content(
+                  role='user',
+                  parts=[
+                    types.Part.from_uri(
+                        file_uri=file_uris[0],
+                        mime_type='application/pdf'),
+                    types.Part.from_uri(
+                        file_uri=file_uris[1],
+                        mime_type='application/pdf',)])
+          ],
+          system_instruction='What is the sum of the two pdfs?',
           display_name='test cache',
           ttl='3600s',
       ),

{google_genai-0.3.0 → google_genai-0.4.0}/google/genai/__init__.py

@@ -16,7 +16,8 @@
 """Google Gen AI SDK"""
 
 from .client import Client
+from . import  version
 
-__version__ = '0.3.0'
+__version__ = version.__version__
 
 __all__ = ['Client']

{google_genai-0.3.0 → google_genai-0.4.0}/google/genai/_api_client.py

@@ -23,35 +23,66 @@ import datetime
 import json
 import os
 import sys
-from typing import Any, Optional, TypedDict, Union
+from typing import Any, Optional, Tuple, TypedDict, Union
 from urllib.parse import urlparse, urlunparse
 
 import google.auth
 import google.auth.credentials
 from google.auth.transport.requests import AuthorizedSession
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
 import requests
 
 from . import errors
+from . import version
 
 
-class HttpOptions(TypedDict):
+class HttpOptions(BaseModel):
+  """HTTP options for the api client."""
+  model_config = ConfigDict(extra='forbid')
+
+  base_url: Optional[str] = Field(
+      default=None,
+      description="""The base URL for the AI platform service endpoint.""",
+  )
+  api_version: Optional[str] = Field(
+      default=None,
+      description="""Specifies the version of the API to use.""",
+  )
+  headers: Optional[dict[str, str]] = Field(
+      default=None,
+      description="""Additional HTTP headers to be sent with the request.""",
+  )
+  response_payload: Optional[dict] = Field(
+      default=None,
+      description="""If set, the response payload will be returned int the supplied dict.""",
+  )
+  timeout: Optional[Union[float, Tuple[float, float]]] = Field(
+      default=None,
+      description="""Timeout for the request in seconds.""",
+  )
+
+
+class HttpOptionsDict(TypedDict):
   """HTTP options for the api client."""
 
-  base_url: str = None
+  base_url: Optional[str] = None
   """The base URL for the AI platform service endpoint."""
-  api_version: str = None
+  api_version: Optional[str] = None
   """Specifies the version of the API to use."""
-  headers: dict[str, dict] = None
+  headers: Optional[dict[str, Union[str, list[str]]]] = None
   """Additional HTTP headers to be sent with the request."""
-  response_payload: dict = None
+  response_payload: Optional[dict] = None
   """If set, the response payload will be returned int the supplied dict."""
+  timeout: Optional[Union[float, Tuple[float, float]]] = None
+  """Timeout for the request in seconds."""
+
+
+HttpOptionsOrDict = Union[HttpOptions, HttpOptionsDict]
 
 
 def _append_library_version_headers(headers: dict[str, str]) -> None:
   """Appends the telemetry header to the headers dict."""
-  # TODO: Automate revisions to the SDK library version.
-  library_label = f'google-genai-sdk/0.3.0'
+  library_label = f'google-genai-sdk/{version.__version__}'
   language_label = 'gl-python/' + sys.version.split()[0]
   version_header_value = f'{library_label} {language_label}'
   if (
@@ -71,20 +102,24 @@ def _append_library_version_headers(headers: dict[str, str]) -> None:
 
 
 def _patch_http_options(
-    options: HttpOptions, patch_options: HttpOptions
-) -> HttpOptions:
+    options: HttpOptionsDict, patch_options: HttpOptionsDict
+) -> HttpOptionsDict:
   # use shallow copy so we don't override the original objects.
-  copy_option = HttpOptions()
+  copy_option = HttpOptionsDict()
   copy_option.update(options)
-  for k, v in patch_options.items():
+  for patch_key, patch_value in patch_options.items():
     # if both are dicts, update the copy.
     # This is to handle cases like merging headers.
-    if isinstance(v, dict) and isinstance(copy_option.get(k, None), dict):
-      copy_option[k] = {}
-      copy_option[k].update(options[k])  # shallow copy from original options.
-      copy_option[k].update(v)
-    elif v is not None:  # Accept empty values.
-      copy_option[k] = v
+    if isinstance(patch_value, dict) and isinstance(
+        copy_option.get(patch_key, None), dict
+    ):
+      copy_option[patch_key] = {}
+      copy_option[patch_key].update(
+          options[patch_key]
+      )  # shallow copy from original options.
+      copy_option[patch_key].update(patch_value)
+    elif patch_value is not None:  # Accept empty values.
+      copy_option[patch_key] = patch_value
   _append_library_version_headers(copy_option['headers'])
   return copy_option
 
@@ -98,10 +133,11 @@ def _join_url_path(base_url: str, path: str) -> str:
 
 @dataclass
 class HttpRequest:
-  headers: dict[str, str]
+  headers: dict[str, Union[str, list[str]]]
   url: str
   method: str
   data: Union[dict[str, object], bytes]
+  timeout: Optional[Union[float, Tuple[float, float]]] = None
 
 
 class HttpResponse:
@@ -147,7 +183,7 @@ class ApiClient:
       credentials: google.auth.credentials.Credentials = None,
       project: Union[str, None] = None,
       location: Union[str, None] = None,
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsOrDict = None,
   ):
     self.vertexai = vertexai
     if self.vertexai is None:
@@ -163,11 +199,20 @@ class ApiClient:
           'Project/location and API key are mutually exclusive in the client initializer.'
       )
 
+    # Validate http_options if a dict is provided.
+    if isinstance(http_options, dict):
+      try:
+        HttpOptions.model_validate(http_options)
+      except ValidationError as e:
+        raise ValueError(f'Invalid http_options: {e}')
+    elif(isinstance(http_options, HttpOptions)):
+      http_options = http_options.model_dump()
+
     self.api_key: Optional[str] = None
     self.project = project or os.environ.get('GOOGLE_CLOUD_PROJECT', None)
     self.location = location or os.environ.get('GOOGLE_CLOUD_LOCATION', None)
     self._credentials = credentials
-    self._http_options = HttpOptions()
+    self._http_options = HttpOptionsDict()
 
     if self.vertexai:
       if not self.project:
@@ -208,7 +253,7 @@ class ApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsDict = None,
   ) -> HttpRequest:
     # Remove all special dict keys such as _url and _query.
     keys_to_delete = [key for key in request_dict.keys() if key.startswith('_')]
@@ -232,6 +277,7 @@ class ApiClient:
         url=url,
         headers=patched_http_options['headers'],
         data=request_dict,
+        timeout=patched_http_options.get('timeout', None),
     )
 
   def _request(
@@ -250,10 +296,10 @@ class ApiClient:
           http_request.method.upper(),
           http_request.url,
           headers=http_request.headers,
-          data=json.dumps(http_request.data, cls=RequestJsonEncoder) if http_request.data else None,
-          # TODO: support timeout in RequestOptions so it can be configured
-          # per methods.
-          timeout=None,
+          data=json.dumps(http_request.data, cls=RequestJsonEncoder)
+          if http_request.data
+          else None,
+          timeout=http_request.timeout,
       )
       errors.APIError.raise_for_response(response)
       return HttpResponse(
@@ -275,13 +321,14 @@ class ApiClient:
         data = http_request.data
 
     http_session = requests.Session()
-    request = requests.Request(
+    response = http_session.request(
         method=http_request.method,
         url=http_request.url,
         headers=http_request.headers,
         data=data,
-    ).prepare()
-    response = http_session.send(request, stream=stream)
+        timeout=http_request.timeout,
+        stream=stream,
+    )
     errors.APIError.raise_for_response(response)
     return HttpResponse(
         response.headers, response if stream else [response.text]
@@ -307,8 +354,10 @@ class ApiClient:
           stream=stream,
       )
 
-  def get_read_only_http_options(self) -> HttpOptions:
-    copied = HttpOptions()
+  def get_read_only_http_options(self) -> HttpOptionsDict:
+    copied = HttpOptionsDict()
+    if isinstance(self._http_options, BaseModel):
+      self._http_options = self._http_options.model_dump()
     copied.update(self._http_options)
     return copied
 
@@ -317,7 +366,7 @@ class ApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsDict = None,
   ):
     http_request = self._build_request(
         http_method, path, request_dict, http_options
@@ -332,7 +381,7 @@ class ApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsDict = None,
   ):
     http_request = self._build_request(
         http_method, path, request_dict, http_options
@@ -349,7 +398,7 @@ class ApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsDict = None,
   ) -> dict[str, object]:
     http_request = self._build_request(
         http_method, path, request_dict, http_options
@@ -365,7 +414,7 @@ class ApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsDict = None,
   ):
     http_request = self._build_request(
         http_method, path, request_dict, http_options

{google_genai-0.3.0 → google_genai-0.4.0}/google/genai/_automatic_function_calling_util.py

@@ -58,8 +58,8 @@ def _raise_for_nullable_if_mldev(schema: types.Schema):
     )
 
 
-def _raise_if_schema_unsupported(client, schema: types.Schema):
-  if not client.vertexai:
+def _raise_if_schema_unsupported(variant: str, schema: types.Schema):
+  if not variant == 'VERTEX_AI':
     _raise_for_any_of_if_mldev(schema)
     _raise_for_default_if_mldev(schema)
     _raise_for_nullable_if_mldev(schema)
@@ -112,7 +112,7 @@ def _is_default_value_compatible(
 
 
 def _parse_schema_from_parameter(
-    client, param: inspect.Parameter, func_name: str
+    variant: str, param: inspect.Parameter, func_name: str
 ) -> types.Schema:
   """parse schema from parameter.
 
@@ -130,7 +130,7 @@ def _parse_schema_from_parameter(
         raise ValueError(default_value_error_msg)
       schema.default = param.default
     schema.type = _py_builtin_type_to_schema_type[param.annotation]
-    _raise_if_schema_unsupported(client, schema)
+    _raise_if_schema_unsupported(variant, schema)
     return schema
   if (
       isinstance(param.annotation, typing_types.UnionType)
@@ -149,7 +149,7 @@ def _parse_schema_from_parameter(
         schema.nullable = True
         continue
       schema_in_any_of = _parse_schema_from_parameter(
-          client,
+          variant,
           inspect.Parameter(
               'item', inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=arg
           ),
@@ -171,7 +171,7 @@ def _parse_schema_from_parameter(
       if not _is_default_value_compatible(param.default, param.annotation):
         raise ValueError(default_value_error_msg)
       schema.default = param.default
-    _raise_if_schema_unsupported(client, schema)
+    _raise_if_schema_unsupported(variant, schema)
     return schema
   if isinstance(param.annotation, _GenericAlias) or isinstance(
       param.annotation, typing_types.GenericAlias
@@ -184,7 +184,7 @@ def _parse_schema_from_parameter(
         if not _is_default_value_compatible(param.default, param.annotation):
           raise ValueError(default_value_error_msg)
         schema.default = param.default
-      _raise_if_schema_unsupported(client, schema)
+      _raise_if_schema_unsupported(variant, schema)
       return schema
     if origin is Literal:
       if not all(isinstance(arg, str) for arg in args):
@@ -197,12 +197,12 @@ def _parse_schema_from_parameter(
         if not _is_default_value_compatible(param.default, param.annotation):
           raise ValueError(default_value_error_msg)
         schema.default = param.default
-      _raise_if_schema_unsupported(client, schema)
+      _raise_if_schema_unsupported(variant, schema)
       return schema
     if origin is list:
       schema.type = 'ARRAY'
       schema.items = _parse_schema_from_parameter(
-          client,
+          variant,
           inspect.Parameter(
               'item',
               inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -214,7 +214,7 @@ def _parse_schema_from_parameter(
         if not _is_default_value_compatible(param.default, param.annotation):
           raise ValueError(default_value_error_msg)
         schema.default = param.default
-      _raise_if_schema_unsupported(client, schema)
+      _raise_if_schema_unsupported(variant, schema)
       return schema
     if origin is Union:
       schema.any_of = []
@@ -225,7 +225,7 @@ def _parse_schema_from_parameter(
           schema.nullable = True
           continue
         schema_in_any_of = _parse_schema_from_parameter(
-            client,
+            variant,
             inspect.Parameter(
                 'item',
                 inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -249,7 +249,7 @@ def _parse_schema_from_parameter(
         if not _is_default_value_compatible(param.default, param.annotation):
           raise ValueError(default_value_error_msg)
         schema.default = param.default
-      _raise_if_schema_unsupported(client, schema)
+      _raise_if_schema_unsupported(variant, schema)
       return schema
       # all other generic alias will be invoked in raise branch
   if (
@@ -266,7 +266,7 @@ def _parse_schema_from_parameter(
     schema.properties = {}
     for field_name, field_info in param.annotation.model_fields.items():
       schema.properties[field_name] = _parse_schema_from_parameter(
-          client,
+          variant,
           inspect.Parameter(
               field_name,
               inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -274,7 +274,7 @@ def _parse_schema_from_parameter(
           ),
           func_name,
       )
-    _raise_if_schema_unsupported(client, schema)
+    _raise_if_schema_unsupported(variant, schema)
     return schema
   raise ValueError(
       f'Failed to parse the parameter {param} of function {func_name} for'

{google_genai-0.3.0 → google_genai-0.4.0}/google/genai/_replay_api_client.py

@@ -15,6 +15,7 @@
 
 """Replay API client."""
 
+import base64
 import copy
 import inspect
 import json
@@ -105,28 +106,6 @@ def redact_http_request(http_request: HttpRequest):
   _redact_request_body(http_request.data)
 
 
-def process_bytes_fields(data: dict[str, object]):
-  """Converts bytes fields to strings.
-
-  This function doesn't modify the content of data dict.
-  """
-  if not isinstance(data, dict):
-    return data
-  for key, value in data.items():
-    if isinstance(value, bytes):
-      data[key] = value.decode()
-    elif isinstance(value, dict):
-      process_bytes_fields(value)
-    elif isinstance(value, list):
-      if all(isinstance(v, bytes) for v in value):
-        data[key] = [v.decode() for v in value]
-      else:
-        data[key] = [process_bytes_fields(v) for v in value]
-    else:
-      data[key] = value
-  return data
-
-
 def _current_file_path_and_line():
   """Prints the current file path and line number."""
   frame = inspect.currentframe().f_back.f_back
@@ -185,7 +164,7 @@ class ReplayFile(BaseModel):
 
 
 class ReplayApiClient(ApiClient):
-  """For integration testing, send recorded responese or records a response."""
+  """For integration testing, send recorded response or records a response."""
 
   def __init__(
       self,
@@ -280,9 +259,18 @@ class ReplayApiClient(ApiClient):
     replay_file_path = self._get_replay_file_path()
     os.makedirs(os.path.dirname(replay_file_path), exist_ok=True)
     with open(replay_file_path, 'w') as f:
+      replay_session_dict = self.replay_session.model_dump()
+      # Use for non-utf-8 bytes in image/video... output.
+      for interaction in replay_session_dict['interactions']:
+        segments = []
+        for response in interaction['response']['sdk_response_segments']:
+          segments.append(json.loads(json.dumps(
+              response, cls=ResponseJsonEncoder
+          )))
+        interaction['response']['sdk_response_segments'] = segments
       f.write(
           json.dumps(
-              self.replay_session.model_dump(), indent=2, cls=ResponseJsonEncoder
+              replay_session_dict, indent=2, cls=RequestJsonEncoder
           )
       )
     self.replay_session = None
@@ -463,10 +451,16 @@ class ResponseJsonEncoder(json.JSONEncoder):
   """
   def default(self, o):
     if isinstance(o, bytes):
-      # use error replace because response need to be serialized with bytes
-      # string, not base64 string. Otherwise, we cannot tell the response is
-      # already decoded from base64 or not from the replay file.
-      return o.decode(encoding='utf-8', errors='replace')
+      # Use base64.b64encode() to encode bytes to string so that the media bytes
+      # fields are serializable.
+      # o.decode(encoding='utf-8', errors='replace') doesn't work because it
+      # uses a fixed error string `\ufffd` for all non-utf-8 characters,
+      # which cannot be converted back to original bytes. And other languages
+      # only have the original bytes to compare with.
+      # Since we use base64.b64encoding() in replay test, a change that breaks
+      # native bytes can be captured by
+      # test_compute_tokens.py::test_token_bytes_deserialization.
+      return base64.b64encode(o).decode(encoding='utf-8')
     elif isinstance(o, datetime.datetime):
       # dt.isoformat() prints "2024-11-15T23:27:45.624657+00:00"
       # but replay files want "2024-11-15T23:27:45.624657Z"