langchain-google-genai 2.1.11__py3-none-any.whl → 2.1.12__py3-none-any.whl

langchain_google_genai/__init__.py

@@ -1,4 +1,4 @@
-"""**LangChain Google Generative AI Integration**
+"""**LangChain Google Generative AI Integration**.
 
 This module integrates Google's Generative AI models, specifically the Gemini series, with the LangChain framework. It provides classes for interacting with chat models and generating embeddings, leveraging Google's advanced AI capabilities.
 
@@ -76,12 +76,12 @@ __all__ = [
     "AqaOutput",
     "ChatGoogleGenerativeAI",
     "DoesNotExistsException",
+    "DoesNotExistsException",
     "GenAIAqa",
-    "GoogleGenerativeAIEmbeddings",
     "GoogleGenerativeAI",
+    "GoogleGenerativeAIEmbeddings",
     "GoogleVectorStore",
     "HarmBlockThreshold",
     "HarmCategory",
     "Modality",
-    "DoesNotExistsException",
 ]

langchain_google_genai/_common.py

@@ -13,19 +13,17 @@ _TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID"
 
 
 class GoogleGenerativeAIError(Exception):
-    """
-    Custom exception class for errors associated with the `Google GenAI` API.
-    """
+    """Custom exception class for errors associated with the `Google GenAI` API."""
 
 
 class _BaseGoogleGenerativeAI(BaseModel):
-    """Base class for Google Generative AI LLMs"""
+    """Base class for Google Generative AI LLMs."""
 
     model: str = Field(
         ...,
         description="""The name of the model to use.
 Examples:
-    - gemini-2.5-pro
+    - gemini-2.5-flash
     - models/text-bison-001""",
     )
     """Model name to use."""
@@ -34,28 +32,37 @@ Examples:
     )
     """Google AI API key.
     If not specified will be read from env var ``GOOGLE_API_KEY``."""
+
     credentials: Any = None
     "The default custom credentials (google.auth.credentials.Credentials) to use "
     "when making API calls. If not provided, credentials will be ascertained from "
     "the GOOGLE_API_KEY envvar"
+
     temperature: float = 0.7
-    """Run inference with this temperature. Must be within ``[0.0, 2.0]``."""
+    """Run inference with this temperature. Must be within ``[0.0, 2.0]``. If unset,
+    will default to ``0.7``."""
+
     top_p: Optional[float] = None
     """Decode using nucleus sampling: consider the smallest set of tokens whose
-       probability sum is at least ``top_p``. Must be within ``[0.0, 1.0]``."""
+    probability sum is at least ``top_p``. Must be within ``[0.0, 1.0]``."""
+
     top_k: Optional[int] = None
     """Decode using top-k sampling: consider the set of ``top_k`` most probable tokens.
-       Must be positive."""
+    Must be positive."""
+
     max_output_tokens: Optional[int] = Field(default=None, alias="max_tokens")
     """Maximum number of tokens to include in a candidate. Must be greater than zero.
-       If unset, will default to ``64``."""
+    If unset, will default to ``64``."""
+
     n: int = 1
     """Number of chat completions to generate for each prompt. Note that the API may
-       not return the full ``n`` completions if duplicates are generated."""
-    max_retries: int = 6
-    """The maximum number of retries to make when generating."""
+    not return the full ``n`` completions if duplicates are generated."""
+
+    max_retries: int = Field(default=6, alias="retries")
+    """The maximum number of retries to make when generating. If unset, will default
+    to ``6``."""
 
-    timeout: Optional[float] = None
+    timeout: Optional[float] = Field(default=None, alias="request_timeout")
     """The maximum number of seconds to wait for a response."""
 
     client_options: Optional[Dict] = Field(
@@ -68,6 +75,7 @@ Examples:
     transport: Optional[str] = Field(
         default=None,
         description="A string, one of: [`rest`, `grpc`, `grpc_asyncio`].",
+        alias="api_transport",
     )
     additional_headers: Optional[Dict[str, str]] = Field(
         default=None,
@@ -89,9 +97,9 @@ Examples:
     )
 
     safety_settings: Optional[Dict[HarmCategory, HarmBlockThreshold]] = None
-    """The default safety settings to use for all generations. 
-    
-        For example: 
+    """The default safety settings to use for all generations.
+
+        For example:
 
         .. code-block:: python
             from google.generativeai.types.safety_types import HarmBlockThreshold, HarmCategory
@@ -127,6 +135,7 @@ def get_user_agent(module: Optional[str] = None) -> Tuple[str, str]:
     Args:
         module (Optional[str]):
             Optional. The module for a custom user agent header.
+
     Returns:
         Tuple[str, str]
     """
@@ -148,11 +157,13 @@ def get_client_info(module: Optional[str] = None) -> "ClientInfo":
     Args:
         module (Optional[str]):
             Optional. The module for a custom user agent header.
+
     Returns:
         ``google.api_core.gapic_v1.client_info.ClientInfo``
     """
     client_library_version, user_agent = get_user_agent(module)
-    return ClientInfo(
+    # TODO: remove ignore once google-auth has types.
+    return ClientInfo(  # type: ignore[no-untyped-call]
         client_library_version=client_library_version,
         user_agent=user_agent,
     )

langchain_google_genai/_function_utils.py

@@ -4,6 +4,7 @@ import collections
 import importlib
 import json
 import logging
+from collections.abc import Sequence
 from typing import (
     Any,
     Callable,
@@ -11,7 +12,6 @@ from typing import (
     List,
     Literal,
     Optional,
-    Sequence,
     Type,
     TypedDict,
     Union,
@@ -20,7 +20,7 @@ from typing import (
 
 import google.ai.generativelanguage as glm
 import google.ai.generativelanguage_v1beta.types as gapic
-import proto  # type: ignore[import]
+import proto  # type: ignore[import-untyped]
 from langchain_core.tools import BaseTool
 from langchain_core.tools import tool as callable_as_lc_tool
 from langchain_core.utils.function_calling import (
@@ -48,12 +48,7 @@ TYPE_ENUM = {
 _ALLOWED_SCHEMA_FIELDS = []
 _ALLOWED_SCHEMA_FIELDS.extend([f.name for f in gapic.Schema()._pb.DESCRIPTOR.fields])
 _ALLOWED_SCHEMA_FIELDS.extend(
-    [
-        f
-        for f in gapic.Schema.to_dict(
-            gapic.Schema(), preserving_proto_field_name=False
-        ).keys()
-    ]
+    list(gapic.Schema.to_dict(gapic.Schema(), preserving_proto_field_name=False).keys())
 )
 _ALLOWED_SCHEMA_FIELDS_SET = set(_ALLOWED_SCHEMA_FIELDS)
 
@@ -89,7 +84,7 @@ def _format_json_schema_to_gapic(schema: Dict[str, Any]) -> Dict[str, Any]:
     for key, value in schema.items():
         if key == "definitions":
             continue
-        elif key == "items":
+        if key == "items":
             converted_schema["items"] = _format_json_schema_to_gapic(value)
         elif key == "properties":
             converted_schema["properties"] = _get_properties_from_schema(value)
@@ -142,10 +137,11 @@ def convert_to_genai_function_declarations(
     gapic_tool = gapic.Tool()
     for tool in tools:
         if any(f in gapic_tool for f in ["google_search_retrieval"]):
-            raise ValueError(
+            msg = (
                 "Providing multiple google_search_retrieval"
                 " or mixing with function_declarations is not supported"
             )
+            raise ValueError(msg)
         if isinstance(tool, (gapic.Tool)):
             rt: gapic.Tool = (
                 tool if isinstance(tool, gapic.Tool) else tool._raw_tool  # type: ignore
@@ -171,16 +167,17 @@ def convert_to_genai_function_declarations(
                 gapic_tool.function_declarations.append(fd)
                 continue
             # _ToolDictLike
-            tool = cast(_ToolDict, tool)
+            tool = cast("_ToolDict", tool)
             if "function_declarations" in tool:
                 function_declarations = tool["function_declarations"]
                 if not isinstance(
                     tool["function_declarations"], collections.abc.Sequence
                 ):
-                    raise ValueError(
+                    msg = (
                         "function_declarations should be a list"
                         f"got '{type(function_declarations)}'"
                     )
+                    raise ValueError(msg)
                 if function_declarations:
                     fds = [
                         _format_to_gapic_function_declaration(fd)
@@ -198,7 +195,7 @@ def convert_to_genai_function_declarations(
             if "code_execution" in tool:
                 gapic_tool.code_execution = gapic.CodeExecution(tool["code_execution"])
         else:
-            fd = _format_to_gapic_function_declaration(tool)  # type: ignore[arg-type]
+            fd = _format_to_gapic_function_declaration(tool)
             gapic_tool.function_declarations.append(fd)
     return gapic_tool
 
@@ -221,30 +218,32 @@ def _format_to_gapic_function_declaration(
 ) -> gapic.FunctionDeclaration:
     if isinstance(tool, BaseTool):
         return _format_base_tool_to_function_declaration(tool)
-    elif isinstance(tool, type) and is_basemodel_subclass_safe(tool):
+    if isinstance(tool, type) and is_basemodel_subclass_safe(tool):
         return _convert_pydantic_to_genai_function(tool)
-    elif isinstance(tool, dict):
+    if isinstance(tool, dict):
         if all(k in tool for k in ("type", "function")) and tool["type"] == "function":
             function = tool["function"]
         elif (
             all(k in tool for k in ("name", "description")) and "parameters" not in tool
         ):
-            function = cast(dict, tool)
+            function = cast("dict", tool)
+        elif (
+            "parameters" in tool and tool["parameters"].get("properties")  # type: ignore[index]
+        ):
+            function = convert_to_openai_tool(cast("dict", tool))["function"]
         else:
-            if (
-                "parameters" in tool and tool["parameters"].get("properties")  # type: ignore[index]
-            ):
-                function = convert_to_openai_tool(cast(dict, tool))["function"]
-            else:
-                function = cast(dict, tool)
+            function = cast("dict", tool)
         function["parameters"] = function.get("parameters") or {}
         # Empty 'properties' field not supported.
         if not function["parameters"].get("properties"):
             function["parameters"] = {}
-        return _format_dict_to_function_declaration(cast(FunctionDescription, function))
-    elif callable(tool):
+        return _format_dict_to_function_declaration(
+            cast("FunctionDescription", function)
+        )
+    if callable(tool):
         return _format_base_tool_to_function_declaration(callable_as_lc_tool()(tool))
-    raise ValueError(f"Unsupported tool type {tool}")
+    msg = f"Unsupported tool type {tool}"
+    raise ValueError(msg)
 
 
 def _format_base_tool_to_function_declaration(
@@ -270,10 +269,11 @@ def _format_base_tool_to_function_declaration(
     elif issubclass(tool.args_schema, BaseModelV1):
         schema = tool.args_schema.schema()
     else:
-        raise NotImplementedError(
+        msg = (
             "args_schema must be a Pydantic BaseModel or JSON schema, "
             f"got {tool.args_schema}."
         )
+        raise NotImplementedError(msg)
     parameters = _dict_to_gapic_schema(schema)
 
     return gapic.FunctionDeclaration(
@@ -293,12 +293,11 @@ def _convert_pydantic_to_genai_function(
     elif issubclass(pydantic_model, BaseModelV1):
         schema = pydantic_model.schema()
     else:
-        raise NotImplementedError(
-            f"pydantic_model must be a Pydantic BaseModel, got {pydantic_model}"
-        )
+        msg = f"pydantic_model must be a Pydantic BaseModel, got {pydantic_model}"
+        raise NotImplementedError(msg)
     schema = dereference_refs(schema)
     schema.pop("definitions", None)
-    function_declaration = gapic.FunctionDeclaration(
+    return gapic.FunctionDeclaration(
         name=tool_name if tool_name else schema.get("title"),
         description=tool_description if tool_description else schema.get("description"),
         parameters={
@@ -312,7 +311,6 @@ def _convert_pydantic_to_genai_function(
             "type_": TYPE_ENUM[schema["type"]],
         },
     )
-    return function_declaration
 
 
 def _get_properties_from_schema_any(schema: Any) -> Dict[str, Any]:
@@ -444,8 +442,6 @@ def _get_nullable_type_from_schema(schema: Dict[str, Any]) -> Optional[int]:
         types = [t for t in types if t is not None]  # Remove None values
         if types:
             return types[-1]  # TODO: update FunctionDeclaration and pass all types?
-        else:
-            pass
     elif "type" in schema or "type_" in schema:
         type_ = schema["type"] if "type" in schema else schema["type_"]
         if isinstance(type_, int):
@@ -463,20 +459,16 @@ def _is_nullable_schema(schema: Dict[str, Any]) -> bool:
             _get_nullable_type_from_schema(sub_schema) for sub_schema in schema["anyOf"]
         ]
         return any(t is None for t in types)
-    elif "type" in schema or "type_" in schema:
+    if "type" in schema or "type_" in schema:
         type_ = schema["type"] if "type" in schema else schema["type_"]
         if isinstance(type_, int):
             return False
         stype = str(schema["type"]) if "type" in schema else str(schema["type_"])
         return TYPE_ENUM.get(stype, glm.Type.STRING) is None
-    else:
-        pass
     return False
 
 
-_ToolChoiceType = Union[
-    dict, List[str], str, Literal["auto", "none", "any"], Literal[True]
-]
+_ToolChoiceType = Union[Literal["auto", "none", "any", True], dict, List[str], str]
 
 
 class _FunctionCallingConfigDict(TypedDict):
@@ -516,12 +508,14 @@ def _tool_choice_to_tool_config(
                 "allowed_function_names"
             )
         else:
-            raise ValueError(
+            msg = (
                 f"Unrecognized tool choice format:\n\n{tool_choice=}\n\nShould match "
                 f"Google GenerativeAI ToolConfig or FunctionCallingConfig format."
             )
+            raise ValueError(msg)
     else:
-        raise ValueError(f"Unrecognized tool choice format:\n\n{tool_choice=}")
+        msg = f"Unrecognized tool choice format:\n\n{tool_choice=}"
+        raise ValueError(msg)
     return _ToolConfigDict(
         function_calling_config={
             "mode": mode.upper(),
@@ -533,12 +527,11 @@ def _tool_choice_to_tool_config(
 def is_basemodel_subclass_safe(tool: Type) -> bool:
     if safe_import("langchain_core.utils.pydantic", "is_basemodel_subclass"):
         from langchain_core.utils.pydantic import (
-            is_basemodel_subclass,  # type: ignore[import]
+            is_basemodel_subclass,
         )
 
         return is_basemodel_subclass(tool)
-    else:
-        return issubclass(tool, BaseModel)
+    return issubclass(tool, BaseModel)
 
 
 def safe_import(module_name: str, attribute_name: str = "") -> bool:
@@ -562,7 +555,6 @@ def replace_defs_in_schema(original_schema: dict, defs: Optional[dict] = None) -
     Returns:
         Schema with refs replaced.
     """
-
     new_defs = defs or original_schema.get("$defs")
 
     if new_defs is None or not isinstance(new_defs, dict):
@@ -576,20 +568,19 @@ def replace_defs_in_schema(original_schema: dict, defs: Optional[dict] = None) -
 
         if not isinstance(value, dict):
             resulting_schema[key] = value
-        else:
-            if "$ref" in value:
-                new_value = value.copy()
+        elif "$ref" in value:
+            new_value = value.copy()
 
-                path = new_value.pop("$ref")
-                def_key = _get_def_key_from_schema_path(path)
-                new_item = new_defs.get(def_key)
+            path = new_value.pop("$ref")
+            def_key = _get_def_key_from_schema_path(path)
+            new_item = new_defs.get(def_key)
 
-                assert isinstance(new_item, dict)
-                new_value.update(new_item)
+            assert isinstance(new_item, dict)
+            new_value.update(new_item)
 
-                resulting_schema[key] = replace_defs_in_schema(new_value, defs=new_defs)
-            else:
-                resulting_schema[key] = replace_defs_in_schema(value, defs=new_defs)
+            resulting_schema[key] = replace_defs_in_schema(new_value, defs=new_defs)
+        else:
+            resulting_schema[key] = replace_defs_in_schema(value, defs=new_defs)
 
     return resulting_schema
 

langchain_google_genai/_genai_extension.py

@@ -1,14 +1,15 @@
 """Temporary high-level library of the Google GenerativeAI API.
 
-The content of this file should eventually go into the Python package
-google.generativeai.
+(The content of this file should eventually go into the Python package
+google.generativeai.)
 """
 
 import datetime
 import logging
 import re
+from collections.abc import Iterator, MutableSequence
 from dataclasses import dataclass
-from typing import Any, Dict, Iterator, List, MutableSequence, Optional
+from typing import Any, Dict, List, Optional
 
 import google.ai.generativelanguage as genai
 import langchain_core
@@ -21,7 +22,7 @@ from google.ai.generativelanguage_v1beta import (
 from google.api_core import client_options as client_options_lib
 from google.api_core import exceptions as gapi_exception
 from google.api_core import gapic_v1
-from google.auth import credentials, exceptions  # type: ignore
+from google.auth import credentials, exceptions
 from google.protobuf import timestamp_pb2
 
 _logger = logging.getLogger(__name__)
@@ -41,13 +42,15 @@ class EntityName:
 
     def __post_init__(self) -> None:
         if self.chunk_id is not None and self.document_id is None:
-            raise ValueError(f"Chunk must have document ID but found {self}")
+            msg = f"Chunk must have document ID but found {self}"
+            raise ValueError(msg)
 
     @classmethod
     def from_str(cls, encoded: str) -> "EntityName":
         matched = _NAME_REGEX.match(encoded)
         if not matched:
-            raise ValueError(f"Invalid entity name: {encoded}")
+            msg = f"Invalid entity name: {encoded}"
+            raise ValueError(msg)
 
         return cls(
             corpus_id=matched.group(1),
@@ -186,7 +189,9 @@ class TestCredentials(credentials.Credentials):
         """Raises :class:``InvalidOperation``, test credentials cannot be
         refreshed.
         """
-        raise exceptions.InvalidOperation("Test credentials cannot be refreshed.")
+        msg = "Test credentials cannot be refreshed."
+        # TODO: remove ignore once google-auth has types.
+        raise exceptions.InvalidOperation(msg)  # type: ignore[no-untyped-call]
 
     def apply(self, headers: Any, token: Any = None) -> None:
         """Anonymous credentials do nothing to the request.
@@ -197,7 +202,9 @@ class TestCredentials(credentials.Credentials):
             google.auth.exceptions.InvalidValue: If a token was specified.
         """
         if token is not None:
-            raise exceptions.InvalidValue("Test credentials don't support tokens.")
+            msg = "Test credentials don't support tokens."
+            # TODO: remove ignore once google-auth has types.
+            raise exceptions.InvalidValue(msg)  # type: ignore[no-untyped-call]
 
     def before_request(self, request: Any, method: Any, url: Any, headers: Any) -> None:
         """Test credentials do nothing to the request."""
@@ -214,8 +221,9 @@ def _get_credentials() -> Optional[credentials.Credentials]:
     inferred by the rules specified in google.auth package.
     """
     if _config.testing:
-        return TestCredentials()
-    elif _config.auth_credentials:
+        # TODO: remove ignore once google-auth has types.
+        return TestCredentials()  # type: ignore[no-untyped-call]
+    if _config.auth_credentials:
         return _config.auth_credentials
     return None
 
@@ -224,7 +232,8 @@ def build_semantic_retriever() -> genai.RetrieverServiceClient:
     credentials = _get_credentials()
     return genai.RetrieverServiceClient(
         credentials=credentials,
-        client_info=gapic_v1.client_info.ClientInfo(user_agent=_USER_AGENT),
+        # TODO: remove ignore once google-auth has types.
+        client_info=gapic_v1.client_info.ClientInfo(user_agent=_USER_AGENT),  # type: ignore[no-untyped-call]
         client_options=client_options_lib.ClientOptions(
             api_endpoint=_config.api_endpoint
         ),
@@ -248,7 +257,8 @@ def _prepare_config(
     client_info = (
         client_info
         if client_info
-        else gapic_v1.client_info.ClientInfo(user_agent=_USER_AGENT)
+        # TODO: remove ignore once google-auth has types.
+        else gapic_v1.client_info.ClientInfo(user_agent=_USER_AGENT)  # type: ignore[no-untyped-call]
     )
     config = {
         "credentials": credentials,
@@ -328,10 +338,7 @@ def create_corpus(
     client: genai.RetrieverServiceClient,
 ) -> Corpus:
     name: Optional[str]
-    if corpus_id is not None:
-        name = str(EntityName(corpus_id=corpus_id))
-    else:
-        name = None
+    name = str(EntityName(corpus_id=corpus_id)) if corpus_id is not None else None
 
     new_display_name = display_name or f"Untitled {datetime.datetime.now()}"
 
@@ -441,10 +448,11 @@ def batch_create_chunk(
     if metadatas is None:
         metadatas = [{} for _ in texts]
     if len(texts) != len(metadatas):
-        raise ValueError(
+        msg = (
             f"metadatas's length {len(metadatas)} "
             f"and texts's length {len(texts)} are mismatched"
         )
+        raise ValueError(msg)
 
     doc_name = str(EntityName(corpus_id=corpus_id, document_id=document_id))
 
@@ -571,12 +579,14 @@ def generate_answer(
     prompt: str,
     passages: List[str],
     answer_style: int = genai.GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE,
-    safety_settings: List[genai.SafetySetting] = [],
+    safety_settings: Optional[List[genai.SafetySetting]] = None,
     temperature: Optional[float] = None,
     client: genai.GenerativeServiceClient,
 ) -> GroundedAnswer:
     # TODO: Consider passing in the corpus ID instead of the actual
     # passages.
+    if safety_settings is None:
+        safety_settings = []
     response = client.generate_answer(
         genai.GenerateAnswerRequest(
             contents=[
@@ -626,7 +636,9 @@ def generate_answer(
 # For now, we derive this message from other existing fields.
 def _get_finish_message(candidate: genai.Candidate) -> str:
     finish_messages: Dict[int, str] = {
-        genai.Candidate.FinishReason.MAX_TOKENS: "Maximum token in context window reached",  # noqa: E501
+        genai.Candidate.FinishReason.MAX_TOKENS: (
+            "Maximum token in context window reached"
+        ),
         genai.Candidate.FinishReason.SAFETY: "Blocked because of safety",
         genai.Candidate.FinishReason.RECITATION: "Blocked because of recitation",
     }
@@ -646,7 +658,8 @@ def _convert_to_metadata(metadata: Dict[str, Any]) -> List[genai.CustomMetadata]
         elif isinstance(value, (float, int)):
             c = genai.CustomMetadata(key=key, numeric_value=value)
         else:
-            raise ValueError(f"Metadata value {value} is not supported")
+            msg = f"Metadata value {value} is not supported"
+            raise ValueError(msg)
 
         cs.append(c)
     return cs
@@ -668,7 +681,8 @@ def _convert_filter(fs: Optional[Dict[str, Any]]) -> List[genai.MetadataFilter]:
                 operation=genai.Condition.Operator.EQUAL, numeric_value=value
             )
         else:
-            raise ValueError(f"Filter value {value} is not supported")
+            msg = f"Filter value {value} is not supported"
+            raise ValueError(msg)
 
         filters.append(genai.MetadataFilter(key=key, conditions=[condition]))
 

langchain_google_genai/_image_utils.py

@@ -8,13 +8,13 @@ from enum import Enum
 from typing import Any, Dict
 from urllib.parse import urlparse
 
-import filetype  # type: ignore[import]
+import filetype  # type: ignore[import-untyped]
 import requests
 from google.ai.generativelanguage_v1beta.types import Part
 
 
 class Route(Enum):
-    """Image Loading Route"""
+    """Image Loading Route."""
 
     BASE64 = 1
     LOCAL_FILE = 2
@@ -40,7 +40,6 @@ class ImageBytesLoader:
         Returns:
             Image bytes.
         """
-
         route = self._route(image_string)
 
         if route == Route.BASE64:
@@ -50,18 +49,20 @@ class ImageBytesLoader:
             return self._bytes_from_url(image_string)
 
         if route == Route.LOCAL_FILE:
-            raise ValueError(
+            msg = (
                 "Loading from local files is no longer supported for security reasons. "
                 "Please pass in images as Google Cloud Storage URI, "
                 "b64 encoded image string (data:image/...), or valid image url."
             )
+            raise ValueError(msg)
             return self._bytes_from_file(image_string)
 
-        raise ValueError(
+        msg = (
             "Image string must be one of: Google Cloud Storage URI, "
             "b64 encoded image string (data:image/...), or valid image url."
             f"Instead got '{image_string}'."
         )
+        raise ValueError(msg)
 
     def load_part(self, image_string: str) -> Part:
         """Gets Part for loading from Gemini.
@@ -110,11 +111,12 @@ class ImageBytesLoader:
         if os.path.exists(image_string):
             return Route.LOCAL_FILE
 
-        raise ValueError(
+        msg = (
             "Image string must be one of: "
             "b64 encoded image string (data:image/...) or valid image url."
             f" Instead got '{image_string}'."
         )
+        raise ValueError(msg)
 
     def _bytes_from_b64(self, base64_image: str) -> bytes:
         """Gets image bytes from a base64 encoded string.
@@ -125,7 +127,6 @@ class ImageBytesLoader:
         Returns:
             Image bytes
         """
-
         pattern = r"data:image/\w{2,4};base64,(.*)"
         match = re.search(pattern, base64_image)
 
@@ -133,7 +134,8 @@ class ImageBytesLoader:
             encoded_string = match.group(1)
             return base64.b64decode(encoded_string)
 
-        raise ValueError(f"Error in b64 encoded image. Must follow pattern: {pattern}")
+        msg = f"Error in b64 encoded image. Must follow pattern: {pattern}"
+        raise ValueError(msg)
 
     def _bytes_from_url(self, url: str) -> bytes:
         """Gets image bytes from a public url.
@@ -147,7 +149,6 @@ class ImageBytesLoader:
         Returns:
             Image bytes
         """
-
         response = requests.get(url)
 
         if not response.ok: