langchain-core 0.3.79__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain_core/memory.py

@@ -1,120 +0,0 @@
-"""**Memory** maintains Chain state, incorporating context from past runs.
-
-This module contains memory abstractions from LangChain v0.0.x.
-
-These abstractions are now deprecated and will be removed in LangChain v1.0.0.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-from pydantic import ConfigDict
-
-from langchain_core._api import deprecated
-from langchain_core.load.serializable import Serializable
-from langchain_core.runnables import run_in_executor
-
-
-@deprecated(
-    since="0.3.3",
-    removal="1.0.0",
-    message=(
-        "Please see the migration guide at: "
-        "https://python.langchain.com/docs/versions/migrating_memory/"
-    ),
-)
-class BaseMemory(Serializable, ABC):
-    """Abstract base class for memory in Chains.
-
-    Memory refers to state in Chains. Memory can be used to store information about
-        past executions of a Chain and inject that information into the inputs of
-        future executions of the Chain. For example, for conversational Chains Memory
-        can be used to store conversations and automatically add them to future model
-        prompts so that the model has the necessary context to respond coherently to
-        the latest input.
-
-    Example:
-        .. code-block:: python
-
-            class SimpleMemory(BaseMemory):
-                memories: dict[str, Any] = dict()
-
-                @property
-                def memory_variables(self) -> list[str]:
-                    return list(self.memories.keys())
-
-                def load_memory_variables(
-                    self, inputs: dict[str, Any]
-                ) -> dict[str, str]:
-                    return self.memories
-
-                def save_context(
-                    self, inputs: dict[str, Any], outputs: dict[str, str]
-                ) -> None:
-                    pass
-
-                def clear(self) -> None:
-                    pass
-
-    """
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    @property
-    @abstractmethod
-    def memory_variables(self) -> list[str]:
-        """The string keys this memory class will add to chain inputs."""
-
-    @abstractmethod
-    def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Return key-value pairs given the text input to the chain.
-
-        Args:
-            inputs: The inputs to the chain.
-
-        Returns:
-            A dictionary of key-value pairs.
-        """
-
-    async def aload_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Async return key-value pairs given the text input to the chain.
-
-        Args:
-            inputs: The inputs to the chain.
-
-        Returns:
-            A dictionary of key-value pairs.
-        """
-        return await run_in_executor(None, self.load_memory_variables, inputs)
-
-    @abstractmethod
-    def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
-        """Save the context of this chain run to memory.
-
-        Args:
-            inputs: The inputs to the chain.
-            outputs: The outputs of the chain.
-        """
-
-    async def asave_context(
-        self, inputs: dict[str, Any], outputs: dict[str, str]
-    ) -> None:
-        """Async save the context of this chain run to memory.
-
-        Args:
-            inputs: The inputs to the chain.
-            outputs: The outputs of the chain.
-        """
-        await run_in_executor(None, self.save_context, inputs, outputs)
-
-    @abstractmethod
-    def clear(self) -> None:
-        """Clear memory contents."""
-
-    async def aclear(self) -> None:
-        """Async clear memory contents."""
-        await run_in_executor(None, self.clear)

langchain_core/messages/content_blocks.py

@@ -1,176 +0,0 @@
-"""Types for content blocks."""
-
-import warnings
-from typing import Any, Literal, Union
-
-from pydantic import TypeAdapter, ValidationError
-from typing_extensions import NotRequired, TypedDict
-
-
-class BaseDataContentBlock(TypedDict, total=False):
-    """Base class for data content blocks."""
-
-    mime_type: NotRequired[str]
-    """MIME type of the content block (if needed)."""
-
-
-class URLContentBlock(BaseDataContentBlock):
-    """Content block for data from a URL."""
-
-    type: Literal["image", "audio", "file"]
-    """Type of the content block."""
-    source_type: Literal["url"]
-    """Source type (url)."""
-    url: str
-    """URL for data."""
-
-
-class Base64ContentBlock(BaseDataContentBlock):
-    """Content block for inline data from a base64 string."""
-
-    type: Literal["image", "audio", "file"]
-    """Type of the content block."""
-    source_type: Literal["base64"]
-    """Source type (base64)."""
-    data: str
-    """Data as a base64 string."""
-
-
-class PlainTextContentBlock(BaseDataContentBlock):
-    """Content block for plain text data (e.g., from a document)."""
-
-    type: Literal["file"]
-    """Type of the content block."""
-    source_type: Literal["text"]
-    """Source type (text)."""
-    text: str
-    """Text data."""
-
-
-class IDContentBlock(TypedDict):
-    """Content block for data specified by an identifier."""
-
-    type: Literal["image", "audio", "file"]
-    """Type of the content block."""
-    source_type: Literal["id"]
-    """Source type (id)."""
-    id: str
-    """Identifier for data source."""
-
-
-DataContentBlock = Union[
-    URLContentBlock,
-    Base64ContentBlock,
-    PlainTextContentBlock,
-    IDContentBlock,
-]
-
-_DataContentBlockAdapter: TypeAdapter[DataContentBlock] = TypeAdapter(DataContentBlock)
-
-
-def is_data_content_block(
-    content_block: dict,
-) -> bool:
-    """Check if the content block is a standard data content block.
-
-    Args:
-        content_block: The content block to check.
-
-    Returns:
-        True if the content block is a data content block, False otherwise.
-    """
-    try:
-        _ = _DataContentBlockAdapter.validate_python(content_block)
-    except ValidationError:
-        return False
-    else:
-        return True
-
-
-def convert_to_openai_image_block(content_block: dict[str, Any]) -> dict:
-    """Convert image content block to format expected by OpenAI Chat Completions API.
-
-    Args:
-        content_block: The content block to convert.
-
-    Raises:
-        ValueError: If the source type is not supported or if ``mime_type`` is missing
-            for base64 data.
-
-    Returns:
-        A dictionary formatted for OpenAI's API.
-    """
-    if content_block["source_type"] == "url":
-        return {
-            "type": "image_url",
-            "image_url": {
-                "url": content_block["url"],
-            },
-        }
-    if content_block["source_type"] == "base64":
-        if "mime_type" not in content_block:
-            error_message = "mime_type key is required for base64 data."
-            raise ValueError(error_message)
-        mime_type = content_block["mime_type"]
-        return {
-            "type": "image_url",
-            "image_url": {
-                "url": f"data:{mime_type};base64,{content_block['data']}",
-            },
-        }
-    error_message = "Unsupported source type. Only 'url' and 'base64' are supported."
-    raise ValueError(error_message)
-
-
-def convert_to_openai_data_block(block: dict) -> dict:
-    """Format standard data content block to format expected by OpenAI.
-
-    Args:
-        block: A data content block.
-
-    Raises:
-        ValueError: If the block type or source type is not supported.
-
-    Returns:
-        A dictionary formatted for OpenAI's API.
-    """
-    if block["type"] == "image":
-        formatted_block = convert_to_openai_image_block(block)
-
-    elif block["type"] == "file":
-        if block["source_type"] == "base64":
-            file = {"file_data": f"data:{block['mime_type']};base64,{block['data']}"}
-            if filename := block.get("filename"):
-                file["filename"] = filename
-            elif (metadata := block.get("metadata")) and ("filename" in metadata):
-                file["filename"] = metadata["filename"]
-            else:
-                warnings.warn(
-                    "OpenAI may require a filename for file inputs. Specify a filename "
-                    "in the content block: {'type': 'file', 'source_type': 'base64', "
-                    "'mime_type': 'application/pdf', 'data': '...', "
-                    "'filename': 'my-pdf'}",
-                    stacklevel=1,
-                )
-            formatted_block = {"type": "file", "file": file}
-        elif block["source_type"] == "id":
-            formatted_block = {"type": "file", "file": {"file_id": block["id"]}}
-        else:
-            error_msg = "source_type base64 or id is required for file blocks."
-            raise ValueError(error_msg)
-
-    elif block["type"] == "audio":
-        if block["source_type"] == "base64":
-            audio_format = block["mime_type"].split("/")[-1]
-            formatted_block = {
-                "type": "input_audio",
-                "input_audio": {"data": block["data"], "format": audio_format},
-            }
-        else:
-            error_msg = "source_type base64 is required for audio blocks."
-            raise ValueError(error_msg)
-    else:
-        error_msg = f"Block of type {block['type']} is not supported."
-        raise ValueError(error_msg)
-
-    return formatted_block

langchain_core/prompts/pipeline.py

@@ -1,138 +0,0 @@
-"""[DEPRECATED] Pipeline prompt template."""
-
-from typing import Any
-
-from pydantic import model_validator
-
-from langchain_core._api.deprecation import deprecated
-from langchain_core.prompt_values import PromptValue
-from langchain_core.prompts.base import BasePromptTemplate
-from langchain_core.prompts.chat import BaseChatPromptTemplate
-
-
-def _get_inputs(inputs: dict, input_variables: list[str]) -> dict:
-    return {k: inputs[k] for k in input_variables}
-
-
-@deprecated(
-    since="0.3.22",
-    removal="1.0",
-    message=(
-        "This class is deprecated in favor of chaining individual prompts together."
-    ),
-)
-class PipelinePromptTemplate(BasePromptTemplate):
-    """Pipeline prompt template.
-
-    This has been deprecated in favor of chaining individual prompts together in your
-    code; e.g. using a for loop, you could do:
-
-    .. code-block:: python
-
-        my_input = {"key": "value"}
-        for name, prompt in pipeline_prompts:
-            my_input[name] = prompt.invoke(my_input).to_string()
-        my_output = final_prompt.invoke(my_input)
-
-    Prompt template for composing multiple prompt templates together.
-
-    This can be useful when you want to reuse parts of prompts.
-
-    A PipelinePrompt consists of two main parts:
-
-    - final_prompt: This is the final prompt that is returned
-    - pipeline_prompts: This is a list of tuples, consisting
-      of a string (``name``) and a Prompt Template.
-      Each PromptTemplate will be formatted and then passed
-      to future prompt templates as a variable with
-      the same name as ``name``
-
-    """
-
-    final_prompt: BasePromptTemplate
-    """The final prompt that is returned."""
-    pipeline_prompts: list[tuple[str, BasePromptTemplate]]
-    """A list of tuples, consisting of a string (``name``) and a Prompt Template."""
-
-    @classmethod
-    def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
-
-        Returns:
-            ``["langchain", "prompts", "pipeline"]``
-        """
-        return ["langchain", "prompts", "pipeline"]
-
-    @model_validator(mode="before")
-    @classmethod
-    def get_input_variables(cls, values: dict) -> Any:
-        """Get input variables."""
-        created_variables = set()
-        all_variables = set()
-        for k, prompt in values["pipeline_prompts"]:
-            created_variables.add(k)
-            all_variables.update(prompt.input_variables)
-        values["input_variables"] = list(all_variables.difference(created_variables))
-        return values
-
-    def format_prompt(self, **kwargs: Any) -> PromptValue:
-        """Format the prompt with the inputs.
-
-        Args:
-            kwargs: Any arguments to be passed to the prompt template.
-
-        Returns:
-            A formatted string.
-        """
-        for k, prompt in self.pipeline_prompts:
-            inputs = _get_inputs(kwargs, prompt.input_variables)
-            if isinstance(prompt, BaseChatPromptTemplate):
-                kwargs[k] = prompt.format_messages(**inputs)
-            else:
-                kwargs[k] = prompt.format(**inputs)
-        inputs = _get_inputs(kwargs, self.final_prompt.input_variables)
-        return self.final_prompt.format_prompt(**inputs)
-
-    async def aformat_prompt(self, **kwargs: Any) -> PromptValue:
-        """Async format the prompt with the inputs.
-
-        Args:
-            kwargs: Any arguments to be passed to the prompt template.
-
-        Returns:
-            A formatted string.
-        """
-        for k, prompt in self.pipeline_prompts:
-            inputs = _get_inputs(kwargs, prompt.input_variables)
-            if isinstance(prompt, BaseChatPromptTemplate):
-                kwargs[k] = await prompt.aformat_messages(**inputs)
-            else:
-                kwargs[k] = await prompt.aformat(**inputs)
-        inputs = _get_inputs(kwargs, self.final_prompt.input_variables)
-        return await self.final_prompt.aformat_prompt(**inputs)
-
-    def format(self, **kwargs: Any) -> str:
-        """Format the prompt with the inputs.
-
-        Args:
-            kwargs: Any arguments to be passed to the prompt template.
-
-        Returns:
-            A formatted string.
-        """
-        return self.format_prompt(**kwargs).to_string()
-
-    async def aformat(self, **kwargs: Any) -> str:
-        """Async format the prompt with the inputs.
-
-        Args:
-            kwargs: Any arguments to be passed to the prompt template.
-
-        Returns:
-            A formatted string.
-        """
-        return (await self.aformat_prompt(**kwargs)).to_string()
-
-    @property
-    def _prompt_type(self) -> str:
-        raise ValueError

langchain_core/pydantic_v1/__init__.py

@@ -1,30 +0,0 @@
-"""Pydantic v1 compatibility shim."""
-
-from importlib import metadata
-
-from pydantic.v1 import *  # noqa: F403
-
-from langchain_core._api.deprecation import warn_deprecated
-
-try:
-    _PYDANTIC_MAJOR_VERSION: int = int(metadata.version("pydantic").split(".")[0])
-except metadata.PackageNotFoundError:
-    _PYDANTIC_MAJOR_VERSION = 0
-
-warn_deprecated(
-    "0.3.0",
-    removal="1.0.0",
-    alternative="pydantic.v1 or pydantic",
-    message=(
-        "As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. "
-        "The langchain_core.pydantic_v1 module was a "
-        "compatibility shim for pydantic v1, and should no longer be used. "
-        "Please update the code to import from Pydantic directly.\n\n"
-        "For example, replace imports like: "
-        "`from langchain_core.pydantic_v1 import BaseModel`\n"
-        "with: `from pydantic import BaseModel`\n"
-        "or the v1 compatibility namespace if you are working in a code base "
-        "that has not been fully upgraded to pydantic 2 yet. "
-        "\tfrom pydantic.v1 import BaseModel\n"
-    ),
-)

langchain_core/pydantic_v1/dataclasses.py

@@ -1,23 +0,0 @@
-"""Pydantic v1 compatibility shim."""
-
-from pydantic.v1.dataclasses import *  # noqa: F403
-
-from langchain_core._api import warn_deprecated
-
-warn_deprecated(
-    "0.3.0",
-    removal="1.0.0",
-    alternative="pydantic.v1 or pydantic",
-    message=(
-        "As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. "
-        "The langchain_core.pydantic_v1 module was a "
-        "compatibility shim for pydantic v1, and should no longer be used. "
-        "Please update the code to import from Pydantic directly.\n\n"
-        "For example, replace imports like: "
-        "`from langchain_core.pydantic_v1 import BaseModel`\n"
-        "with: `from pydantic import BaseModel`\n"
-        "or the v1 compatibility namespace if you are working in a code base "
-        "that has not been fully upgraded to pydantic 2 yet. "
-        "\tfrom pydantic.v1 import BaseModel\n"
-    ),
-)

langchain_core/pydantic_v1/main.py

@@ -1,23 +0,0 @@
-"""Pydantic v1 compatibility shim."""
-
-from pydantic.v1.main import *  # noqa: F403
-
-from langchain_core._api import warn_deprecated
-
-warn_deprecated(
-    "0.3.0",
-    removal="1.0.0",
-    alternative="pydantic.v1 or pydantic",
-    message=(
-        "As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. "
-        "The langchain_core.pydantic_v1 module was a "
-        "compatibility shim for pydantic v1, and should no longer be used. "
-        "Please update the code to import from Pydantic directly.\n\n"
-        "For example, replace imports like: "
-        "`from langchain_core.pydantic_v1 import BaseModel`\n"
-        "with: `from pydantic import BaseModel`\n"
-        "or the v1 compatibility namespace if you are working in a code base "
-        "that has not been fully upgraded to pydantic 2 yet. "
-        "\tfrom pydantic.v1 import BaseModel\n"
-    ),
-)

langchain_core/tracers/langchain_v1.py

@@ -1,31 +0,0 @@
-"""This module is deprecated and will be removed in a future release.
-
-Please use LangChainTracer instead.
-"""
-
-from typing import Any
-
-
-def get_headers(*args: Any, **kwargs: Any) -> Any:  # noqa: ARG001
-    """Throw an error because this has been replaced by get_headers.
-
-    Raises:
-        RuntimeError: Always, because this function is deprecated.
-    """
-    msg = (
-        "get_headers for LangChainTracerV1 is no longer supported. "
-        "Please use LangChainTracer instead."
-    )
-    raise RuntimeError(msg)
-
-
-def LangChainTracerV1(*args: Any, **kwargs: Any) -> Any:  # noqa: N802,ARG001
-    """Throw an error because this has been replaced by ``LangChainTracer``.
-
-    Raises:
-        RuntimeError: Always, because this class is deprecated.
-    """
-    msg = (
-        "LangChainTracerV1 is no longer supported. Please use LangChainTracer instead."
-    )
-    raise RuntimeError(msg)

langchain_core/utils/loading.py

@@ -1,35 +0,0 @@
-"""Utilities for loading configurations from langchain_core-hub."""
-
-import warnings
-from typing import Any
-
-from langchain_core._api.deprecation import deprecated
-
-
-@deprecated(
-    since="0.1.30",
-    removal="1.0",
-    message=(
-        "Using the hwchase17/langchain-hub "
-        "repo for prompts is deprecated. Please use "
-        "<https://smith.langchain.com/hub> instead."
-    ),
-)
-def try_load_from_hub(
-    *args: Any,  # noqa: ARG001
-    **kwargs: Any,  # noqa: ARG001
-) -> Any:
-    """[DEPRECATED] Try to load from the old Hub.
-
-    Returns:
-        None always, indicating that we shouldn't load from the old hub.
-    """
-    warnings.warn(
-        "Loading from the deprecated github-based Hub is no longer supported. "
-        "Please use the new LangChain Hub at https://smith.langchain.com/hub instead.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    # return None, which indicates that we shouldn't load from old hub
-    # and might just be a filepath for e.g. load_chain
-    return None