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

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]:
@@ -332,8 +330,10 @@ def _get_properties_from_schema(schema: Dict) -> Dict[str, Any]:
             continue
         properties_item: Dict[str, Union[str, int, Dict, List]] = {}
 
-        # Get description from original schema before any modifications
-        description = v.get("description")
+        # Preserve description and other schema properties before manipulation
+        original_description = v.get("description")
+        original_enum = v.get("enum")
+        original_items = v.get("items")
 
         if v.get("anyOf") and all(
             anyOf_type.get("type") != "null" for anyOf_type in v.get("anyOf", [])
@@ -356,11 +356,34 @@ def _get_properties_from_schema(schema: Dict) -> Dict[str, Any]:
             if any_of_types and item_type_ in [glm.Type.ARRAY, glm.Type.OBJECT]:
                 json_type_ = "array" if item_type_ == glm.Type.ARRAY else "object"
                 # Use Index -1 for consistency with `_get_nullable_type_from_schema`
-                v = [val for val in any_of_types if val.get("type") == json_type_][-1]
+                filtered_schema = [
+                    val for val in any_of_types if val.get("type") == json_type_
+                ][-1]
+                # Merge filtered schema with original properties to preserve enum/items
+                v = filtered_schema.copy()
+                if original_enum and not v.get("enum"):
+                    v["enum"] = original_enum
+                if original_items and not v.get("items"):
+                    v["items"] = original_items
+            elif any_of_types:
+                # For other types (like strings with enums), find the non-null schema
+                # and preserve enum/items from the original anyOf structure
+                non_null_schemas = [
+                    val for val in any_of_types if val.get("type") != "null"
+                ]
+                if non_null_schemas:
+                    filtered_schema = non_null_schemas[-1]
+                    v = filtered_schema.copy()
+                    if original_enum and not v.get("enum"):
+                        v["enum"] = original_enum
+                    if original_items and not v.get("items"):
+                        v["items"] = original_items
 
         if v.get("enum"):
             properties_item["enum"] = v["enum"]
 
+        # Prefer description from the filtered schema, fall back to original
+        description = v.get("description") or original_description
         if description and isinstance(description, str):
             properties_item["description"] = description
 
@@ -417,6 +440,8 @@ def _get_items_from_schema(schema: Union[Dict, List, str]) -> Dict[str, Any]:
             items["description"] = (
                 schema.get("description") or schema.get("title") or ""
             )
+        if "enum" in schema:
+            items["enum"] = schema["enum"]
         if _is_nullable_schema(schema):
             items["nullable"] = True
         if "required" in schema:
@@ -444,8 +469,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 +486,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 +535,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 +554,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 +582,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 +595,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=[
@@ -622,20 +632,41 @@ def generate_answer(
     )
 
 
-# TODO: Use candidate.finish_message when that field is launched.
-# For now, we derive this message from other existing fields.
 def _get_finish_message(candidate: genai.Candidate) -> str:
+    """Get a human-readable finish message from the candidate.
+
+    Uses the official finish_message field if available, otherwise falls back
+    to a manual mapping of finish reasons to descriptive messages.
+    """
+    # Use the official field when available
+    if hasattr(candidate, "finish_message") and candidate.finish_message:
+        return candidate.finish_message
+
+    # Fallback to manual mapping for all known finish reasons
     finish_messages: Dict[int, str] = {
-        genai.Candidate.FinishReason.MAX_TOKENS: "Maximum token in context window reached",  # noqa: E501
+        genai.Candidate.FinishReason.STOP: "Generation completed successfully",
+        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",
+        genai.Candidate.FinishReason.LANGUAGE: "Unsupported language detected",
+        genai.Candidate.FinishReason.BLOCKLIST: "Content hit forbidden terms",
+        genai.Candidate.FinishReason.PROHIBITED_CONTENT: (
+            "Inappropriate content detected"
+        ),
+        genai.Candidate.FinishReason.SPII: "Sensitive personal information detected",
+        genai.Candidate.FinishReason.IMAGE_SAFETY: "Image safety violation",
+        genai.Candidate.FinishReason.MALFORMED_FUNCTION_CALL: "Malformed function call",
+        genai.Candidate.FinishReason.UNEXPECTED_TOOL_CALL: "Unexpected tool call",
+        genai.Candidate.FinishReason.OTHER: "Other generation issue",
+        genai.Candidate.FinishReason.FINISH_REASON_UNSPECIFIED: (
+            "Unspecified finish reason"
+        ),
     }
 
     finish_reason = candidate.finish_reason
-    if finish_reason not in finish_messages:
-        return "Unexpected generation error"
-
-    return finish_messages[finish_reason]
+    return finish_messages.get(finish_reason, "Unexpected generation error")
 
 
 def _convert_to_metadata(metadata: Dict[str, Any]) -> List[genai.CustomMetadata]:
@@ -646,7 +677,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 +700,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: