langchain-google-genai 1.0.3__tar.gz → 1.0.5__tar.gz

{langchain_google_genai-1.0.3 → langchain_google_genai-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 1.0.3
+Version: 1.0.5
 Summary: An integration package connecting Google's genai package and LangChain
 Home-page: https://github.com/langchain-ai/langchain-google
 License: MIT
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: images
 Requires-Dist: google-generativeai (>=0.5.2,<0.6.0)
-Requires-Dist: langchain-core (>=0.1.45,<0.2)
+Requires-Dist: langchain-core (>=0.2.0,<0.3)
 Requires-Dist: pillow (>=10.1.0,<11.0.0) ; extra == "images"
 Project-URL: Repository, https://github.com/langchain-ai/langchain-google
 Project-URL: Source Code, https://github.com/langchain-ai/langchain-google/tree/main/libs/genai

{langchain_google_genai-1.0.3 → langchain_google_genai-1.0.5}/langchain_google_genai/__init__.py

@@ -35,7 +35,7 @@ llm.invoke("Sing a ballad of LangChain.")
 ## Using LLMs
 
 The package also supports generating text with Google's models.
-    
+
 ```python
 from langchain_google_genai import GoogleGenerativeAI
 

langchain_google_genai-1.0.5/langchain_google_genai/_common.py

@@ -0,0 +1,52 @@
+from importlib import metadata
+from typing import Optional, Tuple, TypedDict
+
+from google.api_core.gapic_v1.client_info import ClientInfo
+
+from langchain_google_genai._enums import HarmBlockThreshold, HarmCategory
+
+
+class GoogleGenerativeAIError(Exception):
+    """
+    Custom exception class for errors associated with the `Google GenAI` API.
+    """
+
+
+def get_user_agent(module: Optional[str] = None) -> Tuple[str, str]:
+    r"""Returns a custom user agent header.
+
+    Args:
+        module (Optional[str]):
+            Optional. The module for a custom user agent header.
+    Returns:
+        Tuple[str, str]
+    """
+    try:
+        langchain_version = metadata.version("langchain-google-genai")
+    except metadata.PackageNotFoundError:
+        langchain_version = "0.0.0"
+    client_library_version = (
+        f"{langchain_version}-{module}" if module else langchain_version
+    )
+    return client_library_version, f"langchain-google-genai/{client_library_version}"
+
+
+def get_client_info(module: Optional[str] = None) -> "ClientInfo":
+    r"""Returns a client info object with a custom user agent header.
+
+    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(
+        client_library_version=client_library_version,
+        user_agent=user_agent,
+    )
+
+
+class SafetySettingDict(TypedDict):
+    category: HarmCategory
+    threshold: HarmBlockThreshold

langchain_google_genai-1.0.5/langchain_google_genai/_enums.py

@@ -0,0 +1,6 @@
+import google.ai.generativelanguage_v1beta as genai
+
+HarmBlockThreshold = genai.SafetySetting.HarmBlockThreshold
+HarmCategory = genai.HarmCategory
+
+__all__ = ["HarmBlockThreshold", "HarmCategory"]

{langchain_google_genai-1.0.3 → langchain_google_genai-1.0.5}/langchain_google_genai/_function_utils.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import (
     Any,
+    Callable,
     Dict,
     List,
     Literal,
@@ -10,15 +11,16 @@ from typing import (
     Type,
     TypedDict,
     Union,
+    cast,
 )
 
 import google.ai.generativelanguage as glm
-from google.generativeai.types import Tool as GoogleTool  # type: ignore[import]
-from google.generativeai.types.content_types import (  # type: ignore[import]
-    FunctionCallingConfigType,
-    FunctionDeclarationType,
-    ToolDict,
-    ToolType,
+from google.ai.generativelanguage import (
+    FunctionCallingConfig,
+    FunctionDeclaration,
+)
+from google.ai.generativelanguage import (
+    Tool as GoogleTool,
 )
 from langchain_core.pydantic_v1 import BaseModel
 from langchain_core.tools import BaseTool
@@ -36,51 +38,41 @@ TYPE_ENUM = {
 
 TYPE_ENUM_REVERSE = {v: k for k, v in TYPE_ENUM.items()}
 
+_FunctionDeclarationLike = Union[
+    BaseTool, Type[BaseModel], dict, Callable, FunctionDeclaration
+]
+
+
+class _ToolDict(TypedDict):
+    function_declarations: Sequence[_FunctionDeclarationLike]
+
 
 def convert_to_genai_function_declarations(
     tool: Union[
-        GoogleTool, ToolDict, FunctionDeclarationType, Sequence[FunctionDeclarationType]
+        GoogleTool,
+        _ToolDict,
+        _FunctionDeclarationLike,
+        Sequence[_FunctionDeclarationLike],
     ],
-) -> ToolType:
-    """Convert any tool-like object to a ToolType.
-
-    https://github.com/google-gemini/generative-ai-python/blob/668695ebe3e9de496a36eeb95cb2ed2faba9b939/google/generativeai/types/content_types.py#L574
-    """
+) -> GoogleTool:
     if isinstance(tool, GoogleTool):
-        return tool
-    # check whether a dict is supported by glm, otherwise we parse it explicitly
-    if isinstance(tool, dict):
-        first_function_declaration = tool.get("function_declarations", [None])[0]
-        if isinstance(first_function_declaration, glm.FunctionDeclaration):
-            return tool
-        schema = None
-        try:
-            schema = first_function_declaration.parameters
-        except AttributeError:
-            pass
-        if schema is None:
-            schema = first_function_declaration.get("parameters")
-        if schema is None or isinstance(schema, glm.Schema):
-            return tool
-        return glm.Tool(
+        return cast(GoogleTool, tool)
+    if isinstance(tool, type) and issubclass(tool, BaseModel):
+        return GoogleTool(function_declarations=[_convert_to_genai_function(tool)])
+    if callable(tool):
+        return _convert_tool_to_genai_function(callable_as_lc_tool()(tool))
+    if isinstance(tool, list):
+        return convert_to_genai_function_declarations({"function_declarations": tool})
+    if isinstance(tool, dict) and "function_declarations" in tool:
+        return GoogleTool(
             function_declarations=[
                 _convert_to_genai_function(fc) for fc in tool["function_declarations"]
             ],
         )
-    elif isinstance(tool, type) and issubclass(tool, BaseModel):
-        return glm.Tool(function_declarations=[_convert_to_genai_function(tool)])
-    elif callable(tool):
-        return _convert_tool_to_genai_function(callable_as_lc_tool()(tool))
-    elif isinstance(tool, list):
-        return glm.Tool(
-            function_declarations=[_convert_to_genai_function(fc) for fc in tool]
-        )
-    return glm.Tool(function_declarations=[_convert_to_genai_function(tool)])
+    return GoogleTool(function_declarations=[_convert_to_genai_function(tool)])  # type: ignore[arg-type]
 
 
-def tool_to_dict(tool: Union[glm.Tool, GoogleTool]) -> ToolDict:
-    if isinstance(tool, GoogleTool):
-        tool = tool._proto
+def tool_to_dict(tool: GoogleTool) -> _ToolDict:
     function_declarations = []
     for function_declaration_proto in tool.function_declarations:
         properties: Dict[str, Any] = {}
@@ -108,7 +100,7 @@ def tool_to_dict(tool: Union[glm.Tool, GoogleTool]) -> ToolDict:
     return {"function_declarations": function_declarations}
 
 
-def _convert_to_genai_function(fc: FunctionDeclarationType) -> glm.FunctionDeclaration:
+def _convert_to_genai_function(fc: _FunctionDeclarationLike) -> FunctionDeclaration:
     if isinstance(fc, BaseTool):
         return _convert_tool_to_genai_function(fc)
     elif isinstance(fc, type) and issubclass(fc, BaseModel):
@@ -116,10 +108,9 @@ def _convert_to_genai_function(fc: FunctionDeclarationType) -> glm.FunctionDecla
     elif callable(fc):
         return _convert_tool_to_genai_function(callable_as_lc_tool()(fc))
     elif isinstance(fc, dict):
-        return glm.FunctionDeclaration(
-            name=fc["name"],
-            description=fc.get("description"),
-            parameters={
+        formatted_fc = {"name": fc["name"], "description": fc.get("description")}
+        if "parameters" in fc:
+            formatted_fc["parameters"] = {
                 "properties": {
                     k: {
                         "type_": TYPE_ENUM[v["type"]],
@@ -127,19 +118,19 @@ def _convert_to_genai_function(fc: FunctionDeclarationType) -> glm.FunctionDecla
                     }
                     for k, v in fc["parameters"]["properties"].items()
                 },
-                "required": fc["parameters"].get("required", []),
+                "required": fc.get("parameters", []).get("required", []),
                 "type_": TYPE_ENUM[fc["parameters"]["type"]],
-            },
-        )
+            }
+        return FunctionDeclaration(**formatted_fc)
     else:
         raise ValueError(f"Unsupported function call type {fc}")
 
 
-def _convert_tool_to_genai_function(tool: BaseTool) -> glm.FunctionDeclaration:
+def _convert_tool_to_genai_function(tool: BaseTool) -> FunctionDeclaration:
     if tool.args_schema:
         schema = dereference_refs(tool.args_schema.schema())
         schema.pop("definitions", None)
-        return glm.FunctionDeclaration(
+        return FunctionDeclaration(
             name=tool.name or schema["title"],
             description=tool.description or schema["description"],
             parameters={
@@ -155,7 +146,7 @@ def _convert_tool_to_genai_function(tool: BaseTool) -> glm.FunctionDeclaration:
             },
         )
     else:
-        return glm.FunctionDeclaration(
+        return FunctionDeclaration(
             name=tool.name,
             description=tool.description,
             parameters={
@@ -170,10 +161,10 @@ def _convert_tool_to_genai_function(tool: BaseTool) -> glm.FunctionDeclaration:
 
 def _convert_pydantic_to_genai_function(
     pydantic_model: Type[BaseModel],
-) -> glm.FunctionDeclaration:
+) -> FunctionDeclaration:
     schema = dereference_refs(pydantic_model.schema())
     schema.pop("definitions", None)
-    return glm.FunctionDeclaration(
+    return FunctionDeclaration(
         name=schema["title"],
         description=schema.get("description", ""),
         parameters={
@@ -195,8 +186,13 @@ _ToolChoiceType = Union[
 ]
 
 
+class _FunctionCallingConfigDict(TypedDict):
+    mode: Union[FunctionCallingConfig.Mode, str]
+    allowed_function_names: Optional[List[str]]
+
+
 class _ToolConfigDict(TypedDict):
-    function_calling_config: FunctionCallingConfigType
+    function_calling_config: _FunctionCallingConfigDict
 
 
 def _tool_choice_to_tool_config(

{langchain_google_genai-1.0.3 → langchain_google_genai-1.0.5}/langchain_google_genai/_genai_extension.py

@@ -12,6 +12,12 @@ from typing import Any, Dict, Iterator, List, MutableSequence, Optional
 
 import google.ai.generativelanguage as genai
 import langchain_core
+from google.ai.generativelanguage_v1beta import (
+    GenerativeServiceAsyncClient as v1betaGenerativeServiceAsyncClient,
+)
+from google.ai.generativelanguage_v1beta import (
+    GenerativeServiceClient as v1betaGenerativeServiceClient,
+)
 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
@@ -225,15 +231,66 @@ def build_semantic_retriever() -> genai.RetrieverServiceClient:
     )
 
 
-def build_generative_service() -> genai.GenerativeServiceClient:
-    credentials = _get_credentials()
-    return genai.GenerativeServiceClient(
+def _prepare_config(
+    credentials: Optional[credentials.Credentials] = None,
+    api_key: Optional[str] = None,
+    client_options: Optional[Dict[str, Any]] = None,
+    client_info: Optional[gapic_v1.client_info.ClientInfo] = None,
+    transport: Optional[str] = None,
+) -> Dict[str, Any]:
+    formatted_client_options = {"api_endpoint": _config.api_endpoint}
+    if client_options:
+        formatted_client_options.update(**client_options)
+    if not credentials and api_key:
+        formatted_client_options["api_key"] = api_key
+    elif not credentials and not api_key:
+        credentials = _get_credentials()
+    client_info = (
+        client_info
+        if client_info
+        else gapic_v1.client_info.ClientInfo(user_agent=_USER_AGENT)
+    )
+    config = {
+        "credentials": credentials,
+        "client_info": client_info,
+        "client_options": client_options_lib.ClientOptions(**formatted_client_options),
+        "transport": transport,
+    }
+    return {k: v for k, v in config.items() if v is not None}
+
+
+def build_generative_service(
+    credentials: Optional[credentials.Credentials] = None,
+    api_key: Optional[str] = None,
+    client_options: Optional[Dict[str, Any]] = None,
+    client_info: Optional[gapic_v1.client_info.ClientInfo] = None,
+    transport: Optional[str] = None,
+) -> v1betaGenerativeServiceClient:
+    config = _prepare_config(
         credentials=credentials,
-        client_info=gapic_v1.client_info.ClientInfo(user_agent=_USER_AGENT),
-        client_options=client_options_lib.ClientOptions(
-            api_endpoint=_config.api_endpoint
-        ),
+        api_key=api_key,
+        client_options=client_options,
+        transport=transport,
+        client_info=client_info,
+    )
+    return v1betaGenerativeServiceClient(**config)
+
+
+def build_generative_async_service(
+    credentials: Optional[credentials.Credentials],
+    api_key: Optional[str] = None,
+    client_options: Optional[Dict[str, Any]] = None,
+    client_info: Optional[gapic_v1.client_info.ClientInfo] = None,
+    transport: Optional[str] = None,
+) -> v1betaGenerativeServiceAsyncClient:
+    config = _prepare_config(
+        credentials=credentials,
+        api_key=api_key,
+        client_options=client_options,
+        transport=transport,
+        client_info=client_info,
     )
+    return v1betaGenerativeServiceAsyncClient(**config)
 
 
 def list_corpora(

langchain_google_genai-1.0.5/langchain_google_genai/_image_utils.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import base64
+import mimetypes
+import os
+import re
+from enum import Enum
+from typing import Any, Dict
+from urllib.parse import urlparse
+
+import requests
+from google.ai.generativelanguage_v1beta.types import Part
+
+
+class Route(Enum):
+    """Image Loading Route"""
+
+    BASE64 = 1
+    LOCAL_FILE = 2
+    URL = 3
+
+
+class ImageBytesLoader:
+    """Loads image bytes from multiple sources given a string.
+
+    Currently supported:
+        - B64 Encoded image string
+        - Local file path
+        - URL
+    """
+
+    def load_bytes(self, image_string: str) -> bytes:
+        """Routes to the correct loader based on the image_string.
+
+        Args:
+            image_string: Can be either:
+                    - B64 Encoded image string
+                    - Local file path
+                    - URL
+
+        Returns:
+            Image bytes.
+        """
+
+        route = self._route(image_string)
+
+        if route == Route.BASE64:
+            return self._bytes_from_b64(image_string)
+
+        if route == Route.URL:
+            return self._bytes_from_url(image_string)
+
+        if route == Route.LOCAL_FILE:
+            return self._bytes_from_file(image_string)
+
+        raise ValueError(
+            "Image string must be one of: Google Cloud Storage URI, "
+            "b64 encoded image string (data:image/...), valid image url, "
+            f"or existing local image file. Instead got '{image_string}'."
+        )
+
+    def load_part(self, image_string: str) -> Part:
+        """Gets Part for loading from Gemini.
+
+        Args:
+            image_string: Can be either:
+                    - B64 Encoded image string
+                    - Local file path
+                    - URL
+        """
+        route = self._route(image_string)
+
+        if route == Route.BASE64:
+            bytes_ = self._bytes_from_b64(image_string)
+
+        if route == Route.URL:
+            bytes_ = self._bytes_from_url(image_string)
+
+        if route == Route.LOCAL_FILE:
+            bytes_ = self._bytes_from_file(image_string)
+
+        inline_data: Dict[str, Any] = {"data": bytes_}
+        mime_type, _ = mimetypes.guess_type(image_string)
+        if mime_type:
+            inline_data["mime_type"] = mime_type
+
+        return Part(inline_data=inline_data)
+
+    def _route(self, image_string: str) -> Route:
+        if image_string.startswith("data:image/"):
+            return Route.BASE64
+
+        if self._is_url(image_string):
+            return Route.URL
+
+        if os.path.exists(image_string):
+            return Route.LOCAL_FILE
+
+        raise ValueError(
+            "Image string must be one of: "
+            "b64 encoded image string (data:image/...), valid image url, "
+            f"or existing local image file. Instead got '{image_string}'."
+        )
+
+    def _bytes_from_b64(self, base64_image: str) -> bytes:
+        """Gets image bytes from a base64 encoded string.
+
+        Args:
+            base64_image: Encoded image in b64 format.
+
+        Returns:
+            Image bytes
+        """
+
+        pattern = r"data:image/\w{2,4};base64,(.*)"
+        match = re.search(pattern, base64_image)
+
+        if match is not None:
+            encoded_string = match.group(1)
+            return base64.b64decode(encoded_string)
+
+        raise ValueError(f"Error in b64 encoded image. Must follow pattern: {pattern}")
+
+    def _bytes_from_file(self, file_path: str) -> bytes:
+        """Gets image bytes from a local file path.
+
+        Args:
+            file_path: Existing file path.
+
+        Returns:
+            Image bytes
+        """
+        with open(file_path, "rb") as image_file:
+            image_bytes = image_file.read()
+        return image_bytes
+
+    def _bytes_from_url(self, url: str) -> bytes:
+        """Gets image bytes from a public url.
+
+        Args:
+            url: Valid url.
+
+        Raises:
+            HTTP Error if there is one.
+
+        Returns:
+            Image bytes
+        """
+
+        response = requests.get(url)
+
+        if not response.ok:
+            response.raise_for_status()
+
+        return response.content
+
+    def _is_url(self, url_string: str) -> bool:
+        """Checks if a url is valid.
+
+        Args:
+            url_string: Url to check.
+
+        Returns:
+            Whether the url is valid.
+        """
+        try:
+            result = urlparse(url_string)
+            return all([result.scheme, result.netloc])
+        except Exception:
+            return False
+
+
+def image_bytes_to_b64_string(
+    image_bytes: bytes, encoding: str = "ascii", image_format: str = "png"
+) -> str:
+    """Encodes image bytes into a b64 encoded string.
+
+    Args:
+        image_bytes: Bytes of the image.
+        encoding: Type of encoding in the string. 'ascii' by default.
+        image_format: Format of the image. 'png' by default.
+
+    Returns:
+        B64 image encoded string.
+    """
+    encoded_bytes = base64.b64encode(image_bytes).decode(encoding)
+    return f"data:image/{image_format};base64,{encoded_bytes}"