google-genai 1.31.0__tar.gz → 1.33.0__tar.gz

{google_genai-1.31.0/google_genai.egg-info → google_genai-1.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-genai
-Version: 1.31.0
+Version: 1.33.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0
@@ -183,7 +183,7 @@ Then, you can pass it through the following way:
 
 http_options = types.HttpOptions(
     client_args={'proxy': 'socks5://user:pass@host:port'},
-    async_client_args={'proxy': 'socks5://user:pass@host:port'},,
+    async_client_args={'proxy': 'socks5://user:pass@host:port'},
 )
 
 client=Client(..., http_options=http_options)
@@ -388,7 +388,7 @@ The SDK converts all non function call parts into a content with a `user` role.
 [
   types.UserContent(parts=[
     types.Part.from_uri(
-     file_uri: 'gs://generativeai-downloads/images/scones.jpg',
+      file_uri: 'gs://generativeai-downloads/images/scones.jpg',
       mime_type: 'image/jpeg',
     )
   ])
@@ -824,10 +824,10 @@ user_profile = {
 
 response = client.models.generate_content(
     model='gemini-2.0-flash',
-    contents='Give me information of the United States.',
+    contents='Give me a random user profile.',
     config={
         'response_mime_type': 'application/json',
-        'response_json_schema': userProfile
+        'response_json_schema': user_profile
     },
 )
 print(response.parsed)
@@ -1588,7 +1588,7 @@ batch_job = client.batches.create(
         }],
        "role": "user",
      }],
-     "config:": {"response_modalities": ["text"]},
+     "config": {"response_modalities": ["text"]},
     }],
 )
 

{google_genai-1.31.0 → google_genai-1.33.0}/README.md

@@ -149,7 +149,7 @@ Then, you can pass it through the following way:
 
 http_options = types.HttpOptions(
     client_args={'proxy': 'socks5://user:pass@host:port'},
-    async_client_args={'proxy': 'socks5://user:pass@host:port'},,
+    async_client_args={'proxy': 'socks5://user:pass@host:port'},
 )
 
 client=Client(..., http_options=http_options)
@@ -354,7 +354,7 @@ The SDK converts all non function call parts into a content with a `user` role.
 [
   types.UserContent(parts=[
     types.Part.from_uri(
-     file_uri: 'gs://generativeai-downloads/images/scones.jpg',
+      file_uri: 'gs://generativeai-downloads/images/scones.jpg',
       mime_type: 'image/jpeg',
     )
   ])
@@ -790,10 +790,10 @@ user_profile = {
 
 response = client.models.generate_content(
     model='gemini-2.0-flash',
-    contents='Give me information of the United States.',
+    contents='Give me a random user profile.',
     config={
         'response_mime_type': 'application/json',
-        'response_json_schema': userProfile
+        'response_json_schema': user_profile
     },
 )
 print(response.parsed)
@@ -1554,7 +1554,7 @@ batch_job = client.batches.create(
         }],
        "role": "user",
      }],
-     "config:": {"response_modalities": ["text"]},
+     "config": {"response_modalities": ["text"]},
     }],
 )
 

{google_genai-1.31.0 → google_genai-1.33.0}/google/genai/_api_client.py

@@ -584,13 +584,9 @@ class BaseApiClient:
     # Initialize the lock. This lock will be used to protect access to the
     # credentials. This is crucial for thread safety when multiple coroutines
     # might be accessing the credentials at the same time.
-    try:
-      self._sync_auth_lock = threading.Lock()
-      self._async_auth_lock = asyncio.Lock()
-    except RuntimeError:
-      asyncio.set_event_loop(asyncio.new_event_loop())
-      self._sync_auth_lock = threading.Lock()
-      self._async_auth_lock = asyncio.Lock()
+    self._sync_auth_lock = threading.Lock()
+    self._async_auth_lock: Optional[asyncio.Lock] = None
+    self._async_auth_lock_creation_lock: Optional[asyncio.Lock] = None
 
     # Handle when to use Vertex AI in express mode (api key).
     # Explicit initializer arguments are already validated above.
@@ -903,10 +899,36 @@ class BaseApiClient:
       else:
         raise RuntimeError('Could not resolve API token from the environment')
 
+  async def _get_async_auth_lock(self) -> asyncio.Lock:
+    """Lazily initializes and returns an asyncio.Lock for async authentication.
+
+    This method ensures that a single `asyncio.Lock` instance is created and
+    shared among all asynchronous operations that require authentication,
+    preventing race conditions when accessing or refreshing credentials.
+
+    The lock is created on the first call to this method. An internal async lock
+    is used to protect the creation of the main authentication lock to ensure
+    it's a singleton within the client instance.
+
+    Returns:
+        The asyncio.Lock instance for asynchronous authentication operations.
+    """
+    if self._async_auth_lock is None:
+      # Create async creation lock if needed
+      if self._async_auth_lock_creation_lock is None:
+        self._async_auth_lock_creation_lock = asyncio.Lock()
+
+      async with self._async_auth_lock_creation_lock:
+        if self._async_auth_lock is None:
+          self._async_auth_lock = asyncio.Lock()
+
+    return self._async_auth_lock
+
   async def _async_access_token(self) -> Union[str, Any]:
     """Retrieves the access token for the credentials asynchronously."""
     if not self._credentials:
-      async with self._async_auth_lock:
+      async_auth_lock = await self._get_async_auth_lock()
+      async with async_auth_lock:
         # This ensures that only one coroutine can execute the auth logic at a
         # time for thread safety.
         if not self._credentials:
@@ -920,7 +942,8 @@ class BaseApiClient:
     if self._credentials:
       if self._credentials.expired or not self._credentials.token:
         # Only refresh when it needs to. Default expiration is 3600 seconds.
-        async with self._async_auth_lock:
+        async_auth_lock = await self._get_async_auth_lock()
+        async with async_auth_lock:
           if self._credentials.expired or not self._credentials.token:
             # Double check that the credentials expired before refreshing.
             await asyncio.to_thread(refresh_auth, self._credentials)

google_genai-1.33.0/google/genai/_base_transformers.py

@@ -0,0 +1,26 @@
+# 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.
+#
+
+"""Base transformers for Google GenAI SDK."""
+import base64
+
+# Some fields don't accept url safe base64 encoding.
+# We shouldn't use this transformer if the backend adhere to Cloud Type
+# format https://cloud.google.com/docs/discovery/type-format.
+# TODO(b/389133914,b/390320301): Remove the hack after backend fix the issue.
+def t_bytes(data: bytes) -> str:
+  if not isinstance(data, bytes):
+    return data
+  return base64.b64encode(data).decode('ascii')

google_genai-1.33.0/google/genai/_local_tokenizer_loader.py

@@ -0,0 +1,223 @@
+# 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.
+#
+
+import dataclasses
+import functools
+import hashlib
+import os
+import tempfile
+from typing import Optional, cast
+import uuid
+
+import requests  # type: ignore
+import sentencepiece as spm
+from sentencepiece import sentencepiece_model_pb2
+
+
+# Source of truth: https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models
+_GEMINI_MODELS_TO_TOKENIZER_NAMES = {
+    "gemini-1.0-pro": "gemma2",
+    "gemini-1.5-pro": "gemma2",
+    "gemini-1.5-flash": "gemma2",
+    "gemini-2.5-pro": "gemma3",
+    "gemini-2.5-flash": "gemma3",
+    "gemini-2.5-flash-lite": "gemma3",
+    "gemini-2.0-flash": "gemma3",
+    "gemini-2.0-flash-lite": "gemma3",
+}
+_GEMINI_STABLE_MODELS_TO_TOKENIZER_NAMES = {
+    "gemini-1.0-pro-001": "gemma2",
+    "gemini-1.0-pro-002": "gemma2",
+    "gemini-1.5-pro-001": "gemma2",
+    "gemini-1.5-flash-001": "gemma2",
+    "gemini-1.5-flash-002": "gemma2",
+    "gemini-1.5-pro-002": "gemma2",
+    "gemini-2.5-pro-preview-06-05": "gemma3",
+    "gemini-2.5-pro-preview-05-06": "gemma3",
+    "gemini-2.5-pro-exp-03-25": "gemma3",
+    "gemini-live-2.5-flash": "gemma3",
+    "gemini-2.5-flash-preview-05-20": "gemma3",
+    "gemini-2.5-flash-preview-04-17": "gemma3",
+    "gemini-2.5-flash-lite-preview-06-17": "gemma3",
+    "gemini-2.0-flash-001": "gemma3",
+    "gemini-2.0-flash-lite-001": "gemma3",
+}
+
+
+@dataclasses.dataclass(frozen=True)
+class _TokenizerConfig:
+  model_url: str
+  model_hash: str
+
+
+# TODO: update gemma3 tokenizer
+_TOKENIZERS = {
+    "gemma2": _TokenizerConfig(
+        model_url="https://raw.githubusercontent.com/google/gemma_pytorch/33b652c465537c6158f9a472ea5700e5e770ad3f/tokenizer/tokenizer.model",
+        model_hash=(
+            "61a7b147390c64585d6c3543dd6fc636906c9af3865a5548f27f31aee1d4c8e2"
+        ),
+    ),
+    "gemma3": _TokenizerConfig(
+        model_url="https://raw.githubusercontent.com/google/gemma_pytorch/014acb7ac4563a5f77c76d7ff98f31b568c16508/tokenizer/gemma3_cleaned_262144_v2.spiece.model",
+        model_hash=(
+            "1299c11d7cf632ef3b4e11937501358ada021bbdf7c47638d13c0ee982f2e79c"
+        ),
+    ),
+}
+
+
+def _load_file(file_url_path: str) -> bytes:
+  """Loads file bytes from the given file url path."""
+  resp = requests.get(file_url_path)
+  resp.raise_for_status()
+  return cast(bytes, resp.content)
+
+
+def _is_valid_model(*, model_data: bytes, expected_hash: str) -> bool:
+  """Returns true if the content is valid by checking the hash."""
+  if not expected_hash:
+    raise ValueError("expected_hash is required")
+  return hashlib.sha256(model_data).hexdigest() == expected_hash
+
+
+def _maybe_remove_file(file_path: str) -> None:
+  """Removes the file if exists."""
+  if not os.path.exists(file_path):
+    return
+  try:
+    os.remove(file_path)
+  except OSError:
+    # Don't raise if we cannot remove file.
+    pass
+
+
+def _maybe_load_from_cache(
+    *, file_path: str, expected_hash: str
+) -> Optional[bytes]:
+  """Loads the content from the cache path."""
+  if not os.path.exists(file_path):
+    return None
+  with open(file_path, "rb") as f:
+    content = f.read()
+  if _is_valid_model(model_data=content, expected_hash=expected_hash):
+    return content
+
+  # Cached file corrupted.
+  _maybe_remove_file(file_path)
+  return None
+
+
+def _maybe_save_to_cache(
+    *, cache_dir: str, cache_path: str, content: bytes
+) -> None:
+  """Saves the content to the cache path."""
+  try:
+    os.makedirs(cache_dir, exist_ok=True)
+    tmp_path = cache_dir + "." + str(uuid.uuid4()) + ".tmp"
+    with open(tmp_path, "wb") as f:
+      f.write(content)
+    os.rename(tmp_path, cache_path)
+  except OSError:
+    # Don't raise if we cannot write file.
+    pass
+
+
+def _load_from_url(*, file_url: str, expected_hash: str) -> bytes:
+  """Loads model bytes from the given file url."""
+  content = _load_file(file_url)
+  if not _is_valid_model(model_data=content, expected_hash=expected_hash):
+    actual_hash = hashlib.sha256(content).hexdigest()
+    raise ValueError(
+        "Downloaded model file is corrupted."
+        f" Expected hash {expected_hash}. Got file hash {actual_hash}."
+    )
+  return content
+
+
+def _load(*, file_url: str, expected_hash: str) -> bytes:
+  """Loads model bytes from the given file url.
+
+  1. If the find local cached file for the given url and the cached file hash
+     matches the expected hash, the cached file is returned.
+  2. If local cached file is not found or the hash does not match, the file is
+     downloaded from the given url. And write to local cache and return the
+     file bytes.
+  3. If the file downloaded from the given url does not match the expected
+     hash, raise ValueError.
+
+  Args:
+      file_url: The url of the file to load.
+      expected_hash: The expected hash of the file.
+
+  Returns:
+      The file bytes.
+  """
+  model_dir = os.path.join(tempfile.gettempdir(), "vertexai_tokenizer_model")
+  filename = hashlib.sha1(file_url.encode()).hexdigest()
+  model_path = os.path.join(model_dir, filename)
+
+  model_data = _maybe_load_from_cache(
+      file_path=model_path, expected_hash=expected_hash
+  )
+  if not model_data:
+    model_data = _load_from_url(file_url=file_url, expected_hash=expected_hash)
+
+  _maybe_save_to_cache(
+      cache_dir=model_dir, cache_path=model_path, content=model_data
+  )
+  return model_data
+
+
+def _load_model_proto_bytes(tokenizer_name: str) -> bytes:
+  """Loads model proto bytes from the given tokenizer name."""
+  if tokenizer_name not in _TOKENIZERS:
+    raise ValueError(
+        f"Tokenizer {tokenizer_name} is not supported."
+        f"Supported tokenizers: {list(_TOKENIZERS.keys())}"
+    )
+  return _load(
+      file_url=_TOKENIZERS[tokenizer_name].model_url,
+      expected_hash=_TOKENIZERS[tokenizer_name].model_hash,
+  )
+
+
+@functools.lru_cache()
+def load_model_proto(
+    tokenizer_name: str,
+) -> sentencepiece_model_pb2.ModelProto:
+  """Loads model proto from the given tokenizer name."""
+  model_proto = sentencepiece_model_pb2.ModelProto()
+  model_proto.ParseFromString(_load_model_proto_bytes(tokenizer_name))
+  return model_proto
+
+
+def get_tokenizer_name(model_name: str) -> str:
+  """Gets the tokenizer name for the given model name."""
+  if model_name in _GEMINI_MODELS_TO_TOKENIZER_NAMES.keys():
+    return _GEMINI_MODELS_TO_TOKENIZER_NAMES[model_name]
+  if model_name in _GEMINI_STABLE_MODELS_TO_TOKENIZER_NAMES.keys():
+    return _GEMINI_STABLE_MODELS_TO_TOKENIZER_NAMES[model_name]
+  raise ValueError(
+      f"Model {model_name} is not supported. Supported models: {', '.join(_GEMINI_MODELS_TO_TOKENIZER_NAMES.keys())}, {', '.join(_GEMINI_STABLE_MODELS_TO_TOKENIZER_NAMES.keys())}.\n"  # pylint: disable=line-too-long
+  )
+
+
+@functools.lru_cache()
+def get_sentencepiece(tokenizer_name: str) -> spm.SentencePieceProcessor:
+  """Loads sentencepiece tokenizer from the given tokenizer name."""
+  processor = spm.SentencePieceProcessor()
+  processor.LoadFromSerializedProto(_load_model_proto_bytes(tokenizer_name))
+  return processor