langchain-google-genai 1.0.2__tar.gz → 1.0.4__tar.gz

{langchain_google_genai-1.0.2 → langchain_google_genai-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 1.0.2
+Version: 1.0.4
 Summary: An integration package connecting Google's genai package and LangChain
 Home-page: https://github.com/langchain-ai/langchain-google
 License: MIT
@@ -12,8 +12,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: images
-Requires-Dist: google-generativeai (>=0.5.0,<0.6.0)
-Requires-Dist: langchain-core (>=0.1.27,<0.2)
+Requires-Dist: google-generativeai (>=0.5.2,<0.6.0)
+Requires-Dist: langchain-core (>=0.1.45,<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.2 → langchain_google_genai-1.0.4}/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.4/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.4/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.4/langchain_google_genai/_function_utils.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Type,
+    TypedDict,
+    Union,
+    cast,
+)
+
+import google.ai.generativelanguage as glm
+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
+from langchain_core.tools import tool as callable_as_lc_tool
+from langchain_core.utils.json_schema import dereference_refs
+
+TYPE_ENUM = {
+    "string": glm.Type.STRING,
+    "number": glm.Type.NUMBER,
+    "integer": glm.Type.INTEGER,
+    "boolean": glm.Type.BOOLEAN,
+    "array": glm.Type.ARRAY,
+    "object": glm.Type.OBJECT,
+}
+
+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,
+        _FunctionDeclarationLike,
+        Sequence[_FunctionDeclarationLike],
+    ],
+) -> GoogleTool:
+    if isinstance(tool, GoogleTool):
+        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"]
+            ],
+        )
+    return GoogleTool(function_declarations=[_convert_to_genai_function(tool)])  # type: ignore[arg-type]
+
+
+def tool_to_dict(tool: GoogleTool) -> _ToolDict:
+    function_declarations = []
+    for function_declaration_proto in tool.function_declarations:
+        properties: Dict[str, Any] = {}
+        for property in function_declaration_proto.parameters.properties:
+            property_type = function_declaration_proto.parameters.properties[
+                property
+            ].type
+            property_dict = {"type": TYPE_ENUM_REVERSE[property_type]}
+            property_description = function_declaration_proto.parameters.properties[
+                property
+            ].description
+            if property_description:
+                property_dict["description"] = property_description
+            properties[property] = property_dict
+        function_declaration = {
+            "name": function_declaration_proto.name,
+            "description": function_declaration_proto.description,
+            "parameters": {"type": "object", "properties": properties},
+        }
+        if function_declaration_proto.parameters.required:
+            function_declaration["parameters"][  # type: ignore[index]
+                "required"
+            ] = function_declaration_proto.parameters.required
+        function_declarations.append(function_declaration)
+    return {"function_declarations": function_declarations}
+
+
+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):
+        return _convert_pydantic_to_genai_function(fc)
+    elif callable(fc):
+        return _convert_tool_to_genai_function(callable_as_lc_tool()(fc))
+    elif isinstance(fc, dict):
+        formatted_fc = {"name": fc["name"], "description": fc.get("description")}
+        if "parameters" in fc:
+            formatted_fc["parameters"] = {
+                "properties": {
+                    k: {
+                        "type_": TYPE_ENUM[v["type"]],
+                        "description": v.get("description"),
+                    }
+                    for k, v in fc["parameters"]["properties"].items()
+                },
+                "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) -> FunctionDeclaration:
+    if tool.args_schema:
+        schema = dereference_refs(tool.args_schema.schema())
+        schema.pop("definitions", None)
+        return FunctionDeclaration(
+            name=tool.name or schema["title"],
+            description=tool.description or schema["description"],
+            parameters={
+                "properties": {
+                    k: {
+                        "type_": TYPE_ENUM[v["type"]],
+                        "description": v.get("description"),
+                    }
+                    for k, v in schema["properties"].items()
+                },
+                "required": schema.get("required", []),
+                "type_": TYPE_ENUM[schema["type"]],
+            },
+        )
+    else:
+        return FunctionDeclaration(
+            name=tool.name,
+            description=tool.description,
+            parameters={
+                "properties": {
+                    "__arg1": {"type_": TYPE_ENUM["string"]},
+                },
+                "required": ["__arg1"],
+                "type_": TYPE_ENUM["object"],
+            },
+        )
+
+
+def _convert_pydantic_to_genai_function(
+    pydantic_model: Type[BaseModel],
+) -> FunctionDeclaration:
+    schema = dereference_refs(pydantic_model.schema())
+    schema.pop("definitions", None)
+    return FunctionDeclaration(
+        name=schema["title"],
+        description=schema.get("description", ""),
+        parameters={
+            "properties": {
+                k: {
+                    "type_": TYPE_ENUM[v["type"]],
+                    "description": v.get("description"),
+                }
+                for k, v in schema["properties"].items()
+            },
+            "required": schema["required"],
+            "type_": TYPE_ENUM[schema["type"]],
+        },
+    )
+
+
+_ToolChoiceType = Union[
+    dict, List[str], str, Literal["auto", "none", "any"], Literal[True]
+]
+
+
+class _FunctionCallingConfigDict(TypedDict):
+    mode: Union[FunctionCallingConfig.Mode, str]
+    allowed_function_names: Optional[List[str]]
+
+
+class _ToolConfigDict(TypedDict):
+    function_calling_config: _FunctionCallingConfigDict
+
+
+def _tool_choice_to_tool_config(
+    tool_choice: _ToolChoiceType,
+    all_names: List[str],
+) -> _ToolConfigDict:
+    allowed_function_names: Optional[List[str]] = None
+    if tool_choice is True or tool_choice == "any":
+        mode = "any"
+        allowed_function_names = all_names
+    elif tool_choice == "auto":
+        mode = "auto"
+    elif tool_choice == "none":
+        mode = "none"
+    elif isinstance(tool_choice, str):
+        mode = "any"
+        allowed_function_names = [tool_choice]
+    elif isinstance(tool_choice, list):
+        mode = "any"
+        allowed_function_names = tool_choice
+    elif isinstance(tool_choice, dict):
+        if "mode" in tool_choice:
+            mode = tool_choice["mode"]
+            allowed_function_names = tool_choice.get("allowed_function_names")
+        elif "function_calling_config" in tool_choice:
+            mode = tool_choice["function_calling_config"]["mode"]
+            allowed_function_names = tool_choice["function_calling_config"].get(
+                "allowed_function_names"
+            )
+        else:
+            raise ValueError(
+                f"Unrecognized tool choice format:\n\n{tool_choice=}\n\nShould match "
+                f"Google GenerativeAI ToolConfig or FunctionCallingConfig format."
+            )
+    else:
+        raise ValueError(f"Unrecognized tool choice format:\n\n{tool_choice=}")
+    return _ToolConfigDict(
+        function_calling_config={
+            "mode": mode,
+            "allowed_function_names": allowed_function_names,
+        }
+    )

{langchain_google_genai-1.0.2 → langchain_google_genai-1.0.4}/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.4/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}"