google-genai 1.40.0__py3-none-any.whl → 1.42.0__py3-none-any.whl

google/genai/_api_client.py

@@ -80,7 +80,7 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger('google_genai._api_client')
 CHUNK_SIZE = 8 * 1024 * 1024  # 8 MB chunk size
-READ_BUFFER_SIZE = 2**20
+READ_BUFFER_SIZE = 2**22
 MAX_RETRY_COUNT = 3
 INITIAL_RETRY_DELAY = 1  # second
 DELAY_MULTIPLIER = 2
@@ -489,6 +489,7 @@ def retry_args(options: Optional[HttpRetryOptions]) -> _common.StringDict:
       'retry': retry,
       'reraise': True,
       'wait': wait,
+      'before_sleep': tenacity.before_sleep_log(logger, logging.INFO),
   }
 
 

google/genai/_common.py

@@ -21,6 +21,7 @@ import datetime
 import enum
 import functools
 import logging
+import re
 import typing
 from typing import Any, Callable, FrozenSet, Optional, Union, get_args, get_origin
 import uuid
@@ -38,7 +39,9 @@ class ExperimentalWarning(Warning):
   """Warning for experimental features."""
 
 
-def set_value_by_path(data: Optional[dict[Any, Any]], keys: list[str], value: Any) -> None:
+def set_value_by_path(
+    data: Optional[dict[Any, Any]], keys: list[str], value: Any
+) -> None:
   """Examples:
 
   set_value_by_path({}, ['a', 'b'], v)
@@ -100,14 +103,19 @@ def set_value_by_path(data: Optional[dict[Any, Any]], keys: list[str], value: An
             f' Existing value: {existing_data}; New value: {value}.'
         )
     else:
-      if (keys[-1] == '_self' and isinstance(data, dict)
-          and isinstance(value, dict)):
+      if (
+          keys[-1] == '_self'
+          and isinstance(data, dict)
+          and isinstance(value, dict)
+      ):
         data.update(value)
       else:
         data[keys[-1]] = value
 
 
-def get_value_by_path(data: Any, keys: list[str]) -> Any:
+def get_value_by_path(
+    data: Any, keys: list[str], *, default_value: Any = None
+) -> Any:
   """Examples:
 
   get_value_by_path({'a': {'b': v}}, ['a', 'b'])
@@ -119,36 +127,141 @@ def get_value_by_path(data: Any, keys: list[str]) -> Any:
     return data
   for i, key in enumerate(keys):
     if not data:
-      return None
+      return default_value
     if key.endswith('[]'):
       key_name = key[:-2]
       if key_name in data:
-        return [get_value_by_path(d, keys[i + 1 :]) for d in data[key_name]]
+        return [
+            get_value_by_path(d, keys[i + 1 :], default_value=default_value)
+            for d in data[key_name]
+        ]
       else:
-        return None
+        return default_value
     elif key.endswith('[0]'):
       key_name = key[:-3]
       if key_name in data and data[key_name]:
-        return get_value_by_path(data[key_name][0], keys[i + 1 :])
+        return get_value_by_path(
+            data[key_name][0], keys[i + 1 :], default_value=default_value
+        )
       else:
-        return None
+        return default_value
     else:
       if key in data:
         data = data[key]
       elif isinstance(data, BaseModel) and hasattr(data, key):
         data = getattr(data, key)
       else:
-        return None
+        return default_value
   return data
 
 
-def convert_to_dict(obj: object) -> Any:
+def move_value_by_path(data: Any, paths: dict[str, str]) -> None:
+  """Moves values from source paths to destination paths.
+
+  Examples:
+    move_value_by_path(
+      {'requests': [{'content': v1}, {'content': v2}]},
+      {'requests[].*': 'requests[].request.*'}
+    )
+      -> {'requests': [{'request': {'content': v1}}, {'request': {'content':
+      v2}}]}
+  """
+  for source_path, dest_path in paths.items():
+    source_keys = source_path.split('.')
+    dest_keys = dest_path.split('.')
+
+    # Determine keys to exclude from wildcard to avoid cyclic references
+    exclude_keys = set()
+    wildcard_idx = -1
+    for i, key in enumerate(source_keys):
+      if key == '*':
+        wildcard_idx = i
+        break
+
+    if wildcard_idx != -1 and len(dest_keys) > wildcard_idx:
+      # Extract the intermediate key between source and dest paths
+      # Example: source=['requests[]', '*'], dest=['requests[]', 'request', '*']
+      # We want to exclude 'request'
+      for i in range(wildcard_idx, len(dest_keys)):
+        key = dest_keys[i]
+        if key != '*' and not key.endswith('[]') and not key.endswith('[0]'):
+          exclude_keys.add(key)
+
+    # Move values recursively
+    _move_value_recursive(data, source_keys, dest_keys, 0, exclude_keys)
+
+
+def _move_value_recursive(
+    data: Any,
+    source_keys: list[str],
+    dest_keys: list[str],
+    key_idx: int,
+    exclude_keys: set[str],
+) -> None:
+  """Recursively moves values from source path to destination path."""
+  if key_idx >= len(source_keys):
+    return
+
+  key = source_keys[key_idx]
+
+  if key.endswith('[]'):
+    # Handle array iteration
+    key_name = key[:-2]
+    if key_name in data and isinstance(data[key_name], list):
+      for item in data[key_name]:
+        _move_value_recursive(
+            item, source_keys, dest_keys, key_idx + 1, exclude_keys
+        )
+  elif key == '*':
+    # Handle wildcard - move all fields
+    if isinstance(data, dict):
+      # Get all keys to move (excluding specified keys)
+      keys_to_move = [
+          k
+          for k in list(data.keys())
+          if not k.startswith('_') and k not in exclude_keys
+      ]
+
+      # Collect values to move
+      values_to_move = {k: data[k] for k in keys_to_move}
+
+      # Set values at destination
+      for k, v in values_to_move.items():
+        # Build destination keys with the field name
+        new_dest_keys = []
+        for dk in dest_keys[key_idx:]:
+          if dk == '*':
+            new_dest_keys.append(k)
+          else:
+            new_dest_keys.append(dk)
+        set_value_by_path(data, new_dest_keys, v)
+
+      # Delete from source
+      for k in keys_to_move:
+        del data[k]
+  else:
+    # Navigate to next level
+    if key in data:
+      _move_value_recursive(
+          data[key], source_keys, dest_keys, key_idx + 1, exclude_keys
+      )
+
+
+def maybe_snake_to_camel(snake_str: str, convert: bool = True) -> str:
+  """Converts a snake_case string to CamelCase, if convert is True."""
+  if not convert:
+    return snake_str
+  return re.sub(r'_([a-zA-Z])', lambda match: match.group(1).upper(), snake_str)
+
+
+def convert_to_dict(obj: object, convert_keys: bool = False) -> Any:
   """Recursively converts a given object to a dictionary.
 
   If the object is a Pydantic model, it uses the model's `model_dump()` method.
 
   Args:
     obj: The object to convert.
+    convert_keys: Whether to convert the keys from snake case to camel case.
 
   Returns:
     A dictionary representation of the object, a list of objects if a list is
@@ -156,17 +269,23 @@ def convert_to_dict(obj: object) -> Any:
     model.
   """
   if isinstance(obj, pydantic.BaseModel):
-    return obj.model_dump(exclude_none=True)
+    return convert_to_dict(obj.model_dump(exclude_none=True), convert_keys)
   elif isinstance(obj, dict):
-    return {key: convert_to_dict(value) for key, value in obj.items()}
+    return {
+        maybe_snake_to_camel(key, convert_keys): convert_to_dict(
+            value, convert_keys
+        )
+        for key, value in obj.items()
+    }
   elif isinstance(obj, list):
-    return [convert_to_dict(item) for item in obj]
+    return [convert_to_dict(item, convert_keys) for item in obj]
   else:
     return obj
 
 
 def _is_struct_type(annotation: type) -> bool:
   """Checks if the given annotation is list[dict[str, typing.Any]]
+
   or typing.List[typing.Dict[str, typing.Any]].
 
   This maps to Struct type in the API.
@@ -174,7 +293,7 @@ def _is_struct_type(annotation: type) -> bool:
   outer_origin = get_origin(annotation)
   outer_args = get_args(annotation)
 
-  if outer_origin is not list: # Python 3.9+ normalizes list
+  if outer_origin is not list:  # Python 3.9+ normalizes list
     return False
 
   if not outer_args or len(outer_args) != 1:
@@ -185,7 +304,7 @@ def _is_struct_type(annotation: type) -> bool:
   inner_origin = get_origin(inner_annotation)
   inner_args = get_args(inner_annotation)
 
-  if inner_origin is not dict: # Python 3.9+ normalizes to dict
+  if inner_origin is not dict:  # Python 3.9+ normalizes to dict
     return False
 
   if not inner_args or len(inner_args) != 2:
@@ -197,9 +316,7 @@ def _is_struct_type(annotation: type) -> bool:
   return key_type is str and value_type is typing.Any
 
 
-def _remove_extra_fields(
-    model: Any, response: dict[str, object]
-) -> None:
+def _remove_extra_fields(model: Any, response: dict[str, object]) -> None:
   """Removes extra fields from the response that are not in the model.
 
   Mutates the response in place.
@@ -239,6 +356,7 @@ def _remove_extra_fields(
         if isinstance(item, dict):
           _remove_extra_fields(typing.get_args(annotation)[0], item)
 
+
 T = typing.TypeVar('T', bound='BaseModel')
 
 
@@ -378,56 +496,57 @@ def _format_collection(
     depth: int,
     visited: FrozenSet[int],
 ) -> str:
-    """Formats a collection (list, tuple, set)."""
-    if isinstance(obj, list):
-        brackets = ('[', ']')
-        internal_obj = obj
-    elif isinstance(obj, tuple):
-        brackets = ('(', ')')
-        internal_obj = list(obj)
-    elif isinstance(obj, set):
-        internal_obj = list(obj)
-        if obj:
-          brackets = ('{', '}')
-        else:
-          brackets = ('set(', ')')
+  """Formats a collection (list, tuple, set)."""
+  if isinstance(obj, list):
+    brackets = ('[', ']')
+    internal_obj = obj
+  elif isinstance(obj, tuple):
+    brackets = ('(', ')')
+    internal_obj = list(obj)
+  elif isinstance(obj, set):
+    internal_obj = list(obj)
+    if obj:
+      brackets = ('{', '}')
     else:
-        raise ValueError(f"Unsupported collection type: {type(obj)}")
+      brackets = ('set(', ')')
+  else:
+    raise ValueError(f'Unsupported collection type: {type(obj)}')
 
-    if not internal_obj:
-        return brackets[0] + brackets[1]
+  if not internal_obj:
+    return brackets[0] + brackets[1]
 
-    # If the call to _pretty_repr for elements will have depth < 0
-    if depth <= 0:
-        item_count_str = f"{len(internal_obj)} item{'s'*(len(internal_obj)!=1)}"
-        return f'{brackets[0]}<... {item_count_str} at Max depth ...>{brackets[1]}'
-
-    indent = ' ' * indent_level
-    next_indent_str = ' ' * (indent_level + indent_delta)
-    elements = []
-    num_to_show = min(len(internal_obj), max_items)
-
-    for i in range(num_to_show):
-        elem = internal_obj[i]
-        elements.append(
-            next_indent_str
-            + _pretty_repr(
-                elem,
-                indent_level=indent_level + indent_delta,
-                indent_delta=indent_delta,
-                max_len=max_len,
-                max_items=max_items,
-                depth=depth - 1,
-                visited=visited,
-            )
-        )
+  # If the call to _pretty_repr for elements will have depth < 0
+  if depth <= 0:
+    item_count_str = f"{len(internal_obj)} item{'s'*(len(internal_obj)!=1)}"
+    return f'{brackets[0]}<... {item_count_str} at Max depth ...>{brackets[1]}'
 
-    if len(internal_obj) > max_items:
-        elements.append(
-            f'{next_indent_str}<... {len(internal_obj) - max_items} more items ...>'
+  indent = ' ' * indent_level
+  next_indent_str = ' ' * (indent_level + indent_delta)
+  elements = []
+  num_to_show = min(len(internal_obj), max_items)
+
+  for i in range(num_to_show):
+    elem = internal_obj[i]
+    elements.append(
+        next_indent_str
+        + _pretty_repr(
+            elem,
+            indent_level=indent_level + indent_delta,
+            indent_delta=indent_delta,
+            max_len=max_len,
+            max_items=max_items,
+            depth=depth - 1,
+            visited=visited,
         )
+    )
+
+  if len(internal_obj) > max_items:
+    elements.append(
+        f'{next_indent_str}<... {len(internal_obj) - max_items} more items ...>'
+    )
+
+  return f'{brackets[0]}\n' + ',\n'.join(elements) + f',\n{indent}{brackets[1]}'
 
-    return f'{brackets[0]}\n' + ',\n'.join(elements) + f',\n{indent}{brackets[1]}'
 
 class BaseModel(pydantic.BaseModel):
 
@@ -441,7 +560,7 @@ class BaseModel(pydantic.BaseModel):
       arbitrary_types_allowed=True,
       ser_json_bytes='base64',
       val_json_bytes='base64',
-      ignored_types=(typing.TypeVar,)
+      ignored_types=(typing.TypeVar,),
   )
 
   def __repr__(self) -> str:
@@ -452,7 +571,10 @@ class BaseModel(pydantic.BaseModel):
 
   @classmethod
   def _from_response(
-      cls: typing.Type[T], *, response: dict[str, object], kwargs: dict[str, object]
+      cls: typing.Type[T],
+      *,
+      response: dict[str, object],
+      kwargs: dict[str, object],
   ) -> T:
     # To maintain forward compatibility, we need to remove extra fields from
     # the response.
@@ -462,11 +584,11 @@ class BaseModel(pydantic.BaseModel):
     # user may pass a dict that is not a subclass of BaseModel.
     # If more modules require we skip this, we may want a different approach
     should_skip_removing_fields = (
-        kwargs is not None and
-        'config' in kwargs and
-        kwargs['config'] is not None and
-        isinstance(kwargs['config'], dict) and
-        'include_all_fields' in kwargs['config']
+        kwargs is not None
+        and 'config' in kwargs
+        and kwargs['config'] is not None
+        and isinstance(kwargs['config'], dict)
+        and 'include_all_fields' in kwargs['config']
         and kwargs['config']['include_all_fields']
     )
 
@@ -490,7 +612,7 @@ class CaseInSensitiveEnum(str, enum.Enum):
       try:
         return cls[value.lower()]  # Try to access directly with lowercase
       except KeyError:
-        warnings.warn(f"{value} is not a valid {cls.__name__}")
+        warnings.warn(f'{value} is not a valid {cls.__name__}')
         try:
           # Creating a enum instance based on the value
           # We need to use super() to avoid infinite recursion.
@@ -551,10 +673,14 @@ def encode_unserializable_types(data: dict[str, object]) -> dict[str, object]:
   return processed_data
 
 
-def experimental_warning(message: str) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+def experimental_warning(
+    message: str,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
   """Experimental warning, only warns once."""
+
   def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
     warning_done = False
+
     @functools.wraps(func)
     def wrapper(*args: Any, **kwargs: Any) -> Any:
       nonlocal warning_done
@@ -566,13 +692,15 @@ def experimental_warning(message: str) -> Callable[[Callable[..., Any]], Callabl
             stacklevel=2,
         )
       return func(*args, **kwargs)
+
     return wrapper
+
   return decorator
 
 
 def _normalize_key_for_matching(key_str: str) -> str:
   """Normalizes a key for case-insensitive and snake/camel matching."""
-  return key_str.replace("_", "").lower()
+  return key_str.replace('_', '').lower()
 
 
 def align_key_case(
@@ -588,7 +716,9 @@ def align_key_case(
       A new dictionary with keys aligned to target_dict's key casing.
   """
   aligned_update_dict: StringDict = {}
-  target_keys_map = {_normalize_key_for_matching(key): key for key in target_dict.keys()}
+  target_keys_map = {
+      _normalize_key_for_matching(key): key for key in target_dict.keys()
+  }
 
   for key, value in update_dict.items():
     normalized_update_key = _normalize_key_for_matching(key)
@@ -598,9 +728,15 @@ def align_key_case(
     else:
       aligned_key = key
 
-    if isinstance(value, dict) and isinstance(target_dict.get(aligned_key), dict):
-      aligned_update_dict[aligned_key] = align_key_case(target_dict[aligned_key], value)
-    elif isinstance(value, list) and isinstance(target_dict.get(aligned_key), list):
+    if isinstance(value, dict) and isinstance(
+        target_dict.get(aligned_key), dict
+    ):
+      aligned_update_dict[aligned_key] = align_key_case(
+          target_dict[aligned_key], value
+      )
+    elif isinstance(value, list) and isinstance(
+        target_dict.get(aligned_key), list
+    ):
       # Direct assign as we treat update_dict list values as golden source.
       aligned_update_dict[aligned_key] = value
     else:

google/genai/_extra_utils.py

@@ -16,11 +16,13 @@
 """Extra utils depending on types that are shared between sync and async modules."""
 
 import inspect
+import io
 import logging
 import sys
 import typing
 from typing import Any, Callable, Dict, Optional, Union, get_args, get_origin
-
+import mimetypes
+import os
 import pydantic
 
 from . import _common
@@ -541,3 +543,72 @@ def append_chunk_contents(
     contents = t.t_contents(contents)  # type: ignore[assignment]
     if isinstance(contents, list) and chunk_content is not None:
       contents.append(chunk_content)  # type: ignore[arg-type]
+
+
+def prepare_resumable_upload(
+    file: Union[str, os.PathLike[str], io.IOBase],
+    user_http_options: Optional[types.HttpOptionsOrDict] = None,
+    user_mime_type: Optional[str] = None,
+) -> tuple[
+    types.HttpOptions,
+    int,
+    str,
+]:
+  """Prepares the HTTP options, file bytes size and mime type for a resumable upload.
+
+  This function inspects a file (from a path or an in-memory object) to
+  determine its size and MIME type. It then constructs the necessary HTTP
+  headers and options required to initiate a resumable upload session.
+  """
+  size_bytes = None
+  mime_type = user_mime_type
+  if isinstance(file, io.IOBase):
+    if mime_type is None:
+      raise ValueError(
+          'Unknown mime type: Could not determine the mimetype for your'
+          ' file\n please set the `mime_type` argument'
+      )
+    if hasattr(file, 'mode'):
+      if 'b' not in file.mode:
+        raise ValueError('The file must be opened in binary mode.')
+    offset = file.tell()
+    file.seek(0, os.SEEK_END)
+    size_bytes = file.tell() - offset
+    file.seek(offset, os.SEEK_SET)
+  else:
+    fs_path = os.fspath(file)
+    if not fs_path or not os.path.isfile(fs_path):
+      raise FileNotFoundError(f'{file} is not a valid file path.')
+    size_bytes = os.path.getsize(fs_path)
+    if mime_type is None:
+      mime_type, _ = mimetypes.guess_type(fs_path)
+    if mime_type is None:
+      raise ValueError(
+          'Unknown mime type: Could not determine the mimetype for your'
+          ' file\n    please set the `mime_type` argument'
+      )
+  http_options: types.HttpOptions
+  if user_http_options:
+    if isinstance(user_http_options, dict):
+      user_http_options = types.HttpOptions(**user_http_options)
+    http_options = user_http_options
+    http_options.api_version = ''
+    http_options.headers = {
+        'Content-Type': 'application/json',
+        'X-Goog-Upload-Protocol': 'resumable',
+        'X-Goog-Upload-Command': 'start',
+        'X-Goog-Upload-Header-Content-Length': f'{size_bytes}',
+        'X-Goog-Upload-Header-Content-Type': f'{mime_type}',
+    }
+  else:
+    http_options = types.HttpOptions(
+        api_version='',
+        headers={
+            'Content-Type': 'application/json',
+            'X-Goog-Upload-Protocol': 'resumable',
+            'X-Goog-Upload-Command': 'start',
+            'X-Goog-Upload-Header-Content-Length': f'{size_bytes}',
+            'X-Goog-Upload-Header-Content-Type': f'{mime_type}',
+        },
+    )
+  return http_options, size_bytes, mime_type